I wish tech writers would channel their focus elsewhere:

- If you haven't got it working, don't document it. Getting information by talking to SWEs is not enough. Your docs will lack depth and preciseness, and it will show. A lot.

- Show fully qualified imports in code samples. If you don't know what that is, ask SWEs. Given a computer with installed dependencies (such as Maven, Pip, npm, etc.), even your (grand)mother should be able to follow the docs.

- Create automated testsuide for your code samples.

- Mandate that lack of docs be a blocker for a release.

When there are docs written in perfect style and English, yet none of the code samples works, or when I have to spend 30 minutes finishing the "obvious" parts of the code to get it to work, that's when I get really frustrated.

The article seems to be deeply focused on the style. I can't remember when I got frustrated with documentation because the style was bad, or because the sentences were too long.

I couldn't champion your bulleted points harder. Honestly, if I had a say in it, any tech writer working on developer documentation should be able to code/build/perform/use whatever task or api they're documenting without the help of an engineer. They should be able to read and understand code, and they should be willing to do so, even more so than the average engineer using some library code. They should be capable of understanding a library deeply and synthesizing and summarizing that understanding for users of the library.

Just as tech writers in the medical field need to know quite a bit about medicine, tech writers in software should be required to know quite a bit about engineering software. There's plenty that do, but there's also quite a few that don't--I think it's a side effect of the field's relative youth.

I really wish more writers would code and do exactly the things you mention, such as implement robust code sample testing, etc.

The ideal technical writer, at least for software engineering documentation, is a hybrid of a traditional technical writer and a software engineer[^1].

[^1]: This excludes user-facing software documentation, which is essentially a totally different field than those that deal with writing for developer or engineer audiences.

This is what made my friend Caroline Rose such a great technical writer. She not only can explain things in clear and simple terms, but she was also an accomplished programmer before branching into technical writing.

Here is a story about the documentation that became Inside Macintosh:

> I sat down to meet with Caroline for the first time, and she couldn't have been more different than the previous writer. As soon as I began to explain the first routine, she started bombarding me with questions. She didn't mind admitting it when she didn't understand something, and she wouldn't stop badgering me until she comprehended every nuance. She began to ask me questions that I didn't know the answers to, like what happened when certain parameters were invalid. I had to keep the source code open on the screen of my Lisa when I met with her, so I could figure out the answers to her questions while she was there.

> Pretty soon, I figured out that if Caroline had trouble understanding something, it probably meant that the design was flawed. On a number of occasions, I told her to come back tomorrow after she asked a penetrating question, and revised the API to fix the flaw that she had pointed out. I began to imagine her questions when I was coding something new, which made me work harder to get things clearer before I went over them with her.

https://www.folklore.org/StoryView.py?story=Inside_Macintosh...

One of my favorite examples from _Inside Macintosh_ is the discussion about the mathematical foundation of QuickDraw. Modern graphic programmers all know that a (0,0,0,0) rectangle is an empty rectangle. But why is that? Why isn't it a single pixel?

The explanation on pages I-138 through I-141 is what made this concept make sense to me. Here's a PDF of _Inside Macintosh_:

http://www.weihenstephan.org/~michaste/pagetable/mac/Inside_...

Besides that section, there are all kinds of examples of how to explain a complicated concept in simple and understandable terms. It's worth a quick skim of the entire book to see what good documentation looks like.

I'm not sure why this is, but I suspect that it's an combination of higher pay and an interest in writing code over writing documentation.

In my experience I would say that a good SWE will attempt to write good documentation, as having to answer questions in the future about how stuff works over and over takes more time than just documenting things properly the first time.

While I'm at it, being a technical writer convinced me that software engineering and technical writing shouldn't be separate roles, because a lot of my time spent asking for clarification about things led to software engineers realizing they shouldn't have done it that way in the first place, and then changing it. If they had to write about it themselves, the feedback loop would have been tighter. Making them separate roles and paying technical writers less money probably started as some business guy's idea of division of labor.

He does say to use bullet lists, but I think this is more about structuring the content and breaking ideas into steps than it is about style or formatting.

His points all seem to focus on providing clarity and useful content to the reader and user.

I'd consider all of the following to be mostly style choices:

* Avoid Meta Writing

* Minimalist Instruction

* The "Constructivism" section, e.g.--Engage in an active dialog, invite users to act “Please try”, “See what happens”, “Explore yourself”

(The above is now what I'd estimate to be like 80% of the article)

The reason why I'd consider that a style is that if you buy a style guide, e.g. the IBM style guide, it would include similar instructions, e.g. "avoid passive voice" or "be more succinct" (though at a more of an implementation level).

It's possible you'd have a better name for it than 'style'. I'd accept that. My original point stands though; most TWs I've seen concern themselves with the letters of the documentation, and omit what I'd consider the most useful about documentation, that is the deep technical details such as maintaining code samples, or writing test suite for the documentation.

1. I think the faults you're picking on in documentation are valid, important, and also probably more organizational/management faults than TWs.

If the people who have to pay employees tend to be willing to pay developers more than they're willing to pay writers, it seems like the best "average" outcome you can expect--even if you go looking for tech writers who know how to develop--is that you get tech writers who can't or don't want to earn more money developing (i.e., they prefer writing over developing strongly enough to turn down the extra pay, don't have the skill/experience to earn more developing, and so on).

Dev/ops tools, methods, and thinking have a lot to bring to tech writing--but I can't imagine many orgs/projects can achieve this without a collaboration between developers and tech writers, or developer-writers sufficiently remunerated for possessing both skillsets.

2. Style issues in writing are much like those in programming. Code style doesn't matter a whole lot when it's a one-developer code base, but it definitely starts to matter when there are more chefs in the kitchen. When you don't nail down what the style is in either domain, everyone follows personal preference. It can work for a while, but it tends towards chaos that requires a lot more work to clean up than it would to be consistent in the first place.

Edit: This isn't to say you aren't right, but that the style issues are a sort of maintenance issue that may seem pointless from the outside but also do need to get settled (though, ideally without extended bikeshedding...)

> A lot of technical writers focus on the style of the text. For example, I've seen tech writers have long discussions (more than 3 hour-long meetings) about title capitalization in our organization.

In general I agree that there are some technical writers who focus way too much on style. I also think that the list of practices that you described --- usability editing your docs, using a CI system and importing sections of the code samples into the docs to ensure that they're always working, being politically forceful about making sure that docs are treated as part of the core product and not an afterthought --- are all great practices. I agree that the practices you described should be established first before any debates about style.

Moving on, I emphatically disagree that minimalist and constructivist instruction are "style" considerations.

Style considerations are arbitrary decisions that you consistently follow in order to convey a sense of professionalism. In your first comment you provided a perfect example of a style consideration: title capitalization (e.g. whether to format your title like this "How to debug your code" or like this "How To Debug Your Code"). If we A/B tested a document to see if there was any change in user success rate based on title capitalization, there would be no difference.

Minimalist and constructivist instruction are guidelines on how to create effective instruction. For example, the minimalist guideline to explain how to recover from errors is a hugely valuable practice which is extremely obvious once you are exposed to the idea, but is somehow a practice that many forget to do.

To put it another way, if we A/B test a documentation set that follows minimalist or constructivist guidelines with a documentation set written by someone who doesn't understand those principles, I will wager money that the minimalist/constructivist doc set will lead to higher user success rates, however we agree to objectively measure that.

Avoiding passive voice is another example of something that may seem like a style consideration but actually goes a long way towards making your communication much more effective. The problem with the passive voice is that it often makes the subject of an action ambiguous. For example if you write "the script is updated" it's not clear who updates the script. If it's something that the user needs to do, it's much better to say "you need to update the script". If the user reads the passive phrasing "the script is updated" and they don't understand that they need to take an action, that's the potential difference between user success and failure.

As a meta note I'd really appreciate if you didn't say "most technical writers focus too much on style" and instead would say something like "the technical writers I've worked with focus too much on style". This is the equivalent of saying "most software engineers are code monkeys with no social skills" and it's really damaging to the credibility of my industry. But I do agree that there are some who focus too much on that BS and you have my word that I'm trying to rid my industry of that bad habit.

Sure. What I was saying is that if you do A/B testing of docs that are written in a non-minimalistic way with correct, functioning code, and docs written in the best style with code samples that do not work, the former will have more value and will generate more of the before-agreed metrics than the later. Consequently, focus on minimalism should come after focus on technical expertise, which is not my experience (and I would go as far to say that it's not the practise of something like 80% of the field).

> As a meta note I'd really appreciate if you didn't say "most technical writers focus too much on style" and instead would say something like "the technical writers I've worked with focus too much on style".

I did say that. I said:

- "... most TWs I've seen ..."

- "A lot of technical writers focus ..."

- "... I've seen tech writers have ..."

I'll grant that there's missing one "... I've seen" in the list above :). But, of course it's only my experience. I don't know tech writers at Google, for example, or Amazon.

> This is the equivalent of saying "most software engineers are code monkeys with no social skills"

It's not because of the ad-hominem.

> What I was saying is that if you do A/B testing of docs that are written in a non-minimalistic way with correct, functioning code, and docs written in the best style with code samples that do not work, the former will have more value and will generate more of the before-agreed metrics than the later.

Yes, also in agreement here. Usable docs is the table stakes.

Sorry about putting words in your mouth! I must have got triggered and jumped the gun without being very careful about looking at the exact words you used.

If the author is here, I’m curious if they took that definition of technical writing from my post? [1] To the best of my memory I feel like I came up with that definition on my own but also wouldn’t be surprised if I subconsciously took it from somewhere else.

[1] https://kayce.basqu.es/blog/metrics/

An aside: did you redesign your website, Kayce? I recall it looking quite different in the past. It looks great! I like the aesthetic.

and later, in an apparent contradiction ...

> You don’t need to tell the reader what you’re going to tell them. Just tell them.

I think this point could be fleshed out better.

Any piece of nonfiction writing, technical or otherwise, that doesn't give me a clear idea about its content may not pass my filter. I see this the most in long-form journalism. But it also pops up when authors focus on themselves, their struggles, and their aspirations in the first couple of paragraphs.

Telling the reader what they're about to read in the first paragraph of a technical piece is a courtesy. People are busy, and they don't have time to wade through a bunch of throat-clearing at the start of a piece. They'll just close the tab and move on.

It goes both ways. I think this aspect of the craft is a bit more of an art than a science. At certain points it's appropriate to signal what you're about to discuss, at others, it's just noise.

In general, anything that functions similarly to an academic abstract is probably useful (saves the reader from potentially wasting time, gives an overview of the general subject matter and idea without delving into details, takes about 1 minute maximum to read).

Well, technically meta-posts about technical writing are not technical writing.

This is because writing is hard. It is just like coding, in the sense that I can revise it three times and still find ways to make it better the fourth time, or the tenth time.

So no writing is perfect, but I think I can often tell when a writer has read the right books (like On Writing Well). Every now and then an article will jump out to me as being 10 times more lucid and concise than the norm --- even though it's still imperfect.

Also I think the rules are not black and white. There is some judgment needed at every turn. Sometimes you will want to bend one rule to preserve another, and people with different tastes will either praise you or blame you for how you make the call.

Some of the C-folk like: -single line (title) -one liner (more than 5 words but less than 20 words) -short paragraph (2-4 lines) -perhaps a RAG or something visual that will show sentiment (if/where appropriate)

and they won't read past that.

So when (I) write documentation/report/what-have-you I need to make one document for all audiences, the Cxx with 1-minute to spend and the actual target/doer that will spend X-days following up the darn thing.

The good thing about technical documents is that you can just skip the parts you don't want to read. But it is there for the people who do want to.

In actual technical documentation, on the other hand, people already know "this is the documentation of program X". And in the various chapters, you can just go ahead and give them a good title, and then go say what it is to say - without first announcing what you'll say.

If an author can't answer these questions, they will likely write something that is perceived as irrelevant, wrong, or simply 'meh'. This is especially true when writing 'technical reports' as opposed to documentation.

I think this is great advice, and applied to teaching. I can't tell you the number of times a professor has said "and then obviously it follows that" or "it's easy to see that". Nearly every time that was uttered in a lecture I wanted to hurl my textbook at the board.

Looking for alternatives? "Is it easy?" or "It might be obvious" work fine. Maybe use those moments as opportunities to check in with your audience. In the written context, maybe offer end/footnotes explaining why it might be obvious/easy.

Roughly: Don't write item/place/npc descriptions that tell the player ("you") anything they should think or feel.

Easier said than done, though.

Everything is so extremely verbose. I don't want to read a 7 paragraph essay about how this or that feature was developed and evolved over time; I just need a one line hint and maybe an example. Believe it or not, your software is not special. We've seen something like it before and get the gist already. I like the style of man pages, where everything is on one page and organized by the flag, i.e. actual usage (puts a hard limit on meandering bullshittery).

You are in the minority, mate. Man pages are walls of text that cover too much detail in too little space. A lot of them lack examples.

Most people will take a simple task-oriented tutorial over an all-encompassing man page. That’s something that Microsoft understood very well back in the ‘90s, providing copious amounts of examples and tutorial on top of basic reference material. It’s part of the reason they saw orders of magnitude more adoption for their stack.

Especially within a company. Once place I worked, a few teams liked to over-document, though it wasn't enforced org-wide. The docs were usually not very helpful, outdated, and yes, I could just read the code faster. I wish they put more effort into better factored code and better names.

It's not perfect, and good documentation is an art, but if you care about your software and your users you'll try to communicate clearly.

> Support error recognition and recovery.

I totally agree with this. You have to teach critical concepts a couple different ways in case one gets skimmed over or misunderstood. We rely on visuals for this--the text should stand independent of the photo / diagram, and vice versa.

I wrote a handbook on technical writing summing up what we've learned over many years of writing iFixit repair guides. https://help.dozuki.com/Tech_Writing/chapter/0

What's needed is something more like peer review, where the "tech writer's" job is to ask hard question from the user POV during development - for varying values of "user", which would include customer, API consumer, and so on.

This wouldn't be code review, because it's about features, interfaces, and expected behaviours, not the fine details of implementation. And it wouldn't be a PM job, because it would be peer feedback in the form of dialog, not management in the form of requirements and specs.

And it should be continuous, so the doc base evolves in parallel with the code base.

And it should not be an afterthought.

This job does not exist yet. And it should, because virtually all orgs have a problem where individual developers become repositories of The Important Knowledge. If they leave it becomes hard to characterise system behaviours and architectures well enough to understand how they work well enough to replace/improve/reverse engineer them.

So IMO there's a niche for people who are competent developers, competent listeners, and competent communicators, who can pull it all together, stay on top of changes, and leave a readable record of the current state of institutional knowledge about projects, practices, stacks, and interfaces.

In terms of general technical writing, style is less of a concern I have. The real challenge is writing efficiently to convey sufficient information to the audience, without staying too high level but also not providing too many details. I often suffer from writers blockz

Of course, there are not gigs. I know nothing of gigs to be honest.

Upwork. Create a profile as a technical writer, and put links to your docs.

I've picked up partime gigs for API documentation, product usage documentation / User Guide, with screenshots and gifs on that platform. If you are US based, even better cos lot of Companies want to hire US based freelancer for TAX reasons and what not.

Upwork search for client even has a filter that says "US only" and I've used that as a client also, to hire freelancers from within US.

Besides traditional technical writing, there are also gigs for Technical blog posts on various subjects. Avoid the one-off gigs that are low paying, and focus on startups or companies that have already paid for other gigs (you can see it in their profile).

Here are some notes I had:

This is a very weird sentence:

> In the 1980s, they developed a minimalist approach and created a wonderful Operator Training Manual for the IBM Displaywriter, imagine having to introduce someone to using a word processor for the first time.

There is also a misspelling in "the four principals of minimalist instruction".

In that same section it is confusing to bullet point the four principles but include a summary of the principle at the end of the bullet point. This makes it hard to skim. (It's also self-referential, which the previous section recommends against.)

I’ve found this to be especially useful when writing documentation. If you don’t think in this way them your documentation may end up being an impromptu blend of more than one type, and hence may not be useful for a specific use case. Instead I try to structure the documentation for one of these.

I’ve been writing for years, but I am constantly finding out that I still have a long way to go.

Thanks!