Teach, Don't Tell (2013)
stevelosh.com
stevelosh.com
Articles like this one really aren't helping. If you wrote a piece of software I'm using that doesn't make you my teacher. It makes you someone offering a contract, and what I need to know is what that contract says.
The first duty of your documentation is to be complete and correct. Unless you've got that sorted, no amount of "putting yourself in the student's place" is going to give adequate results.
It barely covers the important points of what _should_ be done, and spends a lot of time lampooning bad approaches to documentation.
I also found the metaphor of "the black triangle" obscured the main point of that part of the argument, which to me was "have some foolproof basic starter setup to get a user up and running quickly".
The trouble is that the advice doesn't include ways to make sure your documentation actually covers everything it has to.
What this article says is that you should have « "API documentation" for every user-facing part of your project. »
That commonly leads to "reference" pages which are very little better than the autogenerated documentation the author dismisses. The main problems tend to be that behaviour that isn't controlled by a specific command or function or configuration setting doesn't get documented at all, and that commands with complex behaviour get described using terms that themselves need further definition which isn't provided anywhere.
For example, in Qt you have a view class, a model class, and a selection model class, and none of their pages tell you how to actually select something programmatically. You have to guess or ask ChatGPT these days.
If it's available...
Also, it's much harder to parse multiple files than one doc. Been there, done that, aplenty. Yes, I can find the answer, but that isn't sufficiently going to make it easier. Plus, if one admits the docs are bad because "the source answers that type of in-depth question", then are the docs not still bad?
Another thing to note is that what this article lists as good docs actually cost a lot of time to create. Perhaps this is why people settle for the less than helpful alternatives. I think, though, that it is better to provide a subset of the good docs rather than useless docs that just annoy people.
1. Why/what 2. API spec 3. Tutorial
You need all 3. They are distinct, use different styles, and exist for different purposes and audiences.
Explanation (why, what)
reference (API spec)
tutorials
How to guides
This same set could be easily "transposed" to the contemporary world of web. With all the proper indexing. Why is this "art" "lost" for most of the software :-( ...
BTW, one Excellent incarnation of this documentation art is on the front page right now:
Before the internet, the printed book was all you really got. That meant the company distributing the software had to hire technical writers who'd work with the software devs to create all of this, send it to an editor, and ultimately get published.
We no longer live in an era where tech companies hire tech writers. Software documentation lacking is something that can and limp along with jira cases and support services sold rather than trying to put in the upfront effort to fix everything.
Now, for open source software, hate to say it but the docs have always been pretty crap. Certainly some stands out (usually when the business model was around providing services on top of open source software), but nobody is really paying anyone and few people really want to do that sort of free labor.
The writers can't do their work without input from the technical side and the time for that is often not avaliable.
I know I've been punished for taking time to push ideas to tech writers. Not only does it slow me down in other places, it often gets swept away as unnecessary changes because upstream Sr techs disagree.
For example, when I modify ssl configs, I alway reference the files with soft-links. This makes it so you don't need to modify the config files and simplifies keeping old and new certs so you can flip back during the overlap period you should be providing to test. I try to avoid editing production files by hand whenever possible because in my experience it introduces the possibility to create errors.
I rewrote some docs extending alot of areas with example commands showing how to test things, with explanations that fleshed out the previous quick and dirty documentation. I also modified the method from copy and replace certs, edit files, restart service; to copy files, replace or create soft-link, restart service.
Upstream approvers trashed the whole thing because the thought it was unnecessary and disagreed with me about manually editing config files.
Or so much better than the competition that people use it in spite of poor documentation. Many things like that also grow a cottage industry of people making documentation and teaching (see React or Rails).
Tutorials are teaching a method, like which ends of the pliers you grab. They do not assume a lot of domain knowledge.
HowTos pick the user up where she stands with a concrete problem and walks you through a possible solution of that specific problem. Like how to use pliers to twist a wire just firmly enough to hold two things together.
How to calculate the airspeed velocity of an unladen swallow, etc.
Why don’t they use their proposed system to explain their own system?
It seems like a wasted opportunity. So odd. Or am I missing something?
The docs are there. The information is there, but finding it, is so difficult, that I have often just said "bugger this for a lark," and written my own implementation.
There's two types of docs: The teaching kind, as the article mentions, and the reference kind, for helping folks that already have a start, to find what they need.
I generally do the second. It can be fairly easily generated from inline headerdoc comments, these days, but we still have the issue of indexing, and I still have my work cut out for me, there.
Here's some stuff I wrote about my approach to documentation: https://littlegreenviper.com/leaving-a-legacy/
I've emotionally moved to git for documentation, but I can not get people to follow or transition to better documentation methods once someone is emotionally tied to tribal knowledge and communication.
I got fed up with the Word docx (with code examples) we sent out to our customers and replaced it with a hosted Docusaurus markdown documentation.
It is a lot of work to transfer the knowledge to a the new place. It is a lot of work to keep the documentation up-to-date. It is also a lot of work to formulate things in a widely understandable way with screenshots and good examples.
Still I would do the same refactoring again. While the documentation is still not perfect, our customers now comment that it truly helps them to get going fast with our product. A search function is also very helpful.
Our QA team does follow the integration instructions in the documentation when a major change is released (so "putting somebody in the student's place" does work for us). It of course takes time.
It is probably unrealistic to expect documentation to be complete as it is not clear where the border on inclusiveness goes.
Take eg. AWSs node packages. Here they spend words recommending using async / await which IMHO is firmly outside the scope of library docs.
I am curious on what you feel is missing? is it elements concrete to the piece of software you use, or is it pieces that can be deemed expected knowledge from a professional software developer.
The "be a teacher" motto is how you end up with "documentation" that is a bunch of examples of how to do various things and then no exhaustive and rigorous technical reference or even none at all. And then good luck scouring blog posts and StackOverflow or ask help on IRC (pray it's not on Discord) in the hellscape that has become Internet search if you want to do anything not in the examples.
I spend a lot of time writing documentation. I think it is well written. Many employees do as well. However, some people come to me with questions already answered by the documentation. They aren't interested learning anything, they only want to make their problem into my problem, or they want me to do their job for them. I'm happy to take extra time to guide new employees through something or discuss edge-cases, but with all my day to day tasks, I am simply not given time to spend with senior employees on things answered by the docs.
LLMs can solve this to some extend now tbh.
Not entirely a counter, but i think it's worth remembering that because documentation is difficult - a lot of people have been trained to ignore documentation by way of documentation not being the answer in far too many cases.
I'm sure there are many people whose behavior is driven by the reasons you give, though.
Is your PM/BA/Coworker so overwhelmed they can't think straight (Mind your P's & Q's)? -> Go look at the docs.
Can you politely insert yourself into a conversation with a coworker given their bandwidth and their ability to understand functional and technical requirements and quickly explain what is required? -> Schedule a short meeting.
In fact the best thing to do is to point them to the correct paragraph in the correct document.
I've had a coworker ask me how to do something in a general way, and tell me "please don't tell me 'it depends on the context'. I just want to do my job and go home." Of course, it did depend on the context. Everything does. This is a senior software engineer with 16 years of experience.
You can find the exporters like we did, scrape away. Stop trying to get me to look at it with you
I would like to understand how this would fly for any other domain.
For instance if I buy skillet pan at a home center I generally get 3 lines of advice on how to clean it, and am supposed to then spend perhaps 6 months of trial and error and go through dozens hours or youtube and litterature to become an decent user.
If I buy a car there will be a 400 page user manual, yet no indication on how to replace the rear axle, or how to realign the wheels, or anything that would qualify me as an expert.
If I buy a violin there will be absolutely no instruction whatsoever and I might spend a lifetime to become an expert at it.
Documentation in the real world is usually third party, targeted at a very specific need of a specific public, and isn't supposed to single-handedly make you an expert at anything. I think this gets lost a lot in how people try to document their work and what they expect from projects maintained by volunteers for instance.
PS: by that token, what I expect from documentation is to be absolutely true and accurate. If it's a tall order, no documentation is fine as long as I can spend my time discovering on my own.
A high minded extremely precise but completely obsolete tutorial is IMHO worse than no tutorial in the first place in that a potentially infinite amount of user time will be lost from it, in balance of the few hours the first users gained from it when it was still relevant.
The really outstanding trick of these catalogs is they also work as shortcuts. You can go to a table and pick an O-ring with very little expertise, and it will tell you the groove size, corner radius, etc.
In short, when you're documenting tools or engineering components, and your audience is tool users, teaching is a highly effective approach.
One thing missing in this discussion is that the audience is important. Omega Sensor catalogs are great for design engineers. OTOH, you can find a lot of the same products in a McMaster-Carr catalog, but their focus is on the buyer and they are well optimized to sell to that person.
The article focus is the shape and structure of useful documentation, provided by the project or by third parties, that, the article doesn't say.
Now. Skillets are a commodity. Training material is completely detached from the product, except maybe for cleaning and maintenance. For motor vehicles, driving instruction is detached from the product. The vehicle manual focuses on how to use _this_ car (in contrast to how to use _a_ car, e.g. in traffic). And violin expertise needs a personal trainer.
And likewise, for some programming languages, for example a C compiler, the user manual just teaches how to configure _this_ compiler. It won't teach you C. You buy separate books for C.
But for a new language? a new paradigm?
Let's look at an apples to apples comparison, what would be real-world products of comparable complexity? Advanced Games could be an example. Physical Games that is, like Settlers of Catan.
And of course these come with documentation, because of course they'll desperately fail if the documentation isn't helpful.
We could argue if the presentation of how to get to useful documentation fits today's attention span, I think both the article and the linked resources are very chatty, but the contents is worth reading if you want your technical software product to be successful, imnsho.
On the examples given, we're talking about building tools. The point of a new library is to integrate into projects, understand its model, adjust and maintain it (deal with the requirements, dependencies, upgrade cycle etc), so to me getting taught how to use it is only a small part of the story, and could be potentially irrelevant.
I've used brand new libraries that have absolutely no documentation and it was fine for me and the team.
What the article really focuses on is perhaps more akin to quick onboarding and marketing.
> what would be real-world products of comparable complexity?
A new car will be the same level of complexity. You see it as different if you focus on the simplest part of it (going from A to B), but even for driving a new car will effectively have a learning curve, he tires don't grip the same, the engine requires a different driving style, the length and volume might require adjustement as well. And that's only the tip of the iceberg, as you'll need to understand how it's wired, how the panels are assembled and what standards are used for the parts to maintain or adjust it to your needs. You'll need to dig deeper if you're planning on running it on tracks or races.
Settlers of Catan comes with a booklet because the rules are the game, and the whole point is to bind the players to the rules. That's generally not the case for building tools (except for DRM or license management?), surely not for a new language.
My primary focus is backend development, where I assist developers and solve infrastructure challenges. However, I’m so effective in this role that I often end up boxed into it. I’ve been making an effort to expand into frontend development to broaden my expertise, but this colleague operates in that space and isn't the only one who has made it difficult for others to gain traction.
Proper documentation leads me by the hand, starting on what the software is for, what platforms it runs on, some examples of its use (including examples that show how it is useful for solving real-life problems), a thorough tutorial on how to use it, and finally a complete and properly indexed/searchable reference.
Back in the 1980s, I got myself in trouble: I promised a 100-page manual for a software system I had written, and I decided to do it in the then-new TeX. But this was before The TeXBook was published. So I learned TeX by reading the literate source for the code. The manual was duly ready on time, and served the literally thousands of students who relied on it for the next few years.
But when I finally got a copy of The TeXBook, I was astonished by how little I had actually known about using TeX. I had presumably been mostly using it to answer questions such as “why doesn't this work?”, and a lot of the overall principles had simply not been apparent to me. Once I had learned TeX properly, I learned a great deal about how it all worked by going back and reading the literate source. Knuth is a brilliant (if highly idiosyncratic) programmer.
My point here is to emphasize that when someone releases software, their job is not done unless people can learn to use it. That doesn't just mean completeness and accuracy, but a through-line, apparent to the reader, from learning what it does all the way to mastering it, along with the kind of reference information needed when using it.
If I had to pick, I'd rather a dev tell instead of teach. Other people will inevitably write their "how to do x in y" medium articles anyway. These days you can even get an LLM to write it for you, if there's docs that "tell".
However, I have started using AI to update the README.md lately, and it does a really good job. I review what it creates/updates based on my changes and if looks correct, I check it in. This allows me to focus on stuff the AI cannot do. Yet.
More so, "great docs" tends to mean "docs that tell me exactly how to solve my problem so I don't have to think about it". Otherwise the docs are "bad". It's all about Hickey-esque subjective "ease" and not objective simplicity and excellence. This is why "read the source code" or "read the tests" is treated as a sin here: they demand some kind of interpretative effort from the reader, some sense of adventure, and so on. The author also assumes a priori that the source code will be bad and the tests will be unreadable... but at the same time expects that you will write stellar docs and handhold everyone with the patience of a saint.
If everyone demanded this, there'd be no real open source. Forks would never get picked up, ideas wouldn't get recycled unless they were actively taught, and there wouldn't be an ecosystem.
What this person is basically saying is that it isn't enough to release your code, no, you must in fact write a book and then start a school, and spend all your time patiently dealing with students.
If that's your ambition, great, but the idea that this is the baseline you need to do is absurd. Personally I dislike the kind of student described here very much. I didn't get along with them in college either.
Btw, you can try writing all the docs you want, but nobody will ever tell you why your docs are bad and what would make them better. Just doesn't happen.
It doesn't seem to move the needle like a shipped feature does, requires guessing other peoples' perspectives, involves devoted time and effort (that could, you know, be spent on actually useful things) and the effects of not doing it are invisible (but real: user rage, frustration and wasted time).
Only when the importance of good docs is understood will any effort be invested into it. It should be important if the goal is to have more people using something.