On September 19th and 20th Write the Docs Meeting took place in Prague. This year I had the pleasure to attend. More than 250 people came which is about 40% more compared to last year. On my surprise the majority of the people were actual tech writers or ‘documentarians’ as they called themselves (well there were several talks were they pointed out that they actually don’t have a good, recognisable name).
All of the speakers were tech writers so there wasn’t much correlation with the actual coding or development from the software point of view. Nonetheless there were quite a few tips that I have picked up.
One of the first talks that I found interesting was about writing as a non-native speaker (by Szabó István Zoltán aka Steve). Although his main focus was on language differences and how they affect non-native speaker when he needs to write something (e.g. documentation) he also gave a few tips on how to write in generally. He said you should “Write drunk; edit sober” which I think is a very interesting idea (unfortunately I’m not drunk while writing this). The more technical suggestions were: First do the writing part and then the editing part. In the writing part you should:
- Create the structure,
- estimate the word number
- focus on the flow, don’t mind the grammar.
And in the editing part you should:
- Self-edit,
- grammar checkers,
- read out loud,
- send to the editor.
He also suggested in order to improve your language skills you should start writing your own blog, attend IRL events / conferences and of course read lots of books.
Another interesting talk was about screenshots. Apparently there are some people who can’t create proper screenshots so tech writers must do them themselves. He suggested that we should have screenshot policy style guide which I think is actually a good idea.
There was also one talk about documentation quality and what actually documentation quality is. We have structural and functional quality. Structural is about grammar, style, navigation, etc. Functional quality answers the following questions:
- Does it do what it’s supposed to do?
- Does it satisfy requirements?
- Achieve what it sets out to achieve for users?
Functional quality brings value and this should be our goal. Our goal as a technical writer shouldn’t be that our text is full with nice words that makes average reader harder to understand. It should be plain and simple so that it transports the information as quickly as possible. We should be avare that every sentence has a “user journey” so when you read a sentence your brain actually needs to interpret its information. And the more complex the sentence is the harder is for our brains to do that. We usually label this as “light” (e.g. comics) and “heavy” (e.g. Tolstoy, War and Peace) reading. Let us look at this sentence: “The defendant examined by the lawyer was unreliable”. When we read this sentence we first think that the defendant was doing the examination but then after we read the whole sentence our brain realizes that actually the lawyer was doing the examination. This is called “temporal ambiguity”.
The last talk I want to mention is about (mental) checklists. I found this talk interesting because people (including me) often confuse checklist with todo list. But they are very different. Checklists contains tasks that are repeatable. Checklists are used on a daily basis in a lot of industries. E.g. when airplane pilot takes off or lands a plane he uses checklist to check if he did everything he is suppose to do before taking off or landing.
We have 2 types of checklists: Read-do and do-confirm. They are pretty self explanatory so I will not discuss the differences here. One of the things about checklists we should always have in mind is that if we are using them we should keep them up to date. One of the worst thing that could happen to a checklist is that it contains incorrect items and that in the current process we are actually checking for different things (because we found a better way of doing things but we didn’t update the checklist). That is why I still prefer automatization over checklists (e.g. when deploying, I prefer to use TravisCI).
To wrap up this post I would like to mention a comment that someone (unfortunately I don’t remember his name) on the conference said about github projects. He said that when you are looking at some github project one of the most important things about that project is README file. Then we discussed how many README files are incomplete and/or not updated. In fact every user that opens a github project will first look at README file and if he doesn’t see it there is little chance that he will actually look into the sourcecode (you know this is true).
So to help you out, here is a nice README.rst template that you can use for your projects:
$project
========
$project will solve your problem of where to start with documentation,
by providing a basic explanation of how to do it easily.
Look how easy it is to use:
import project
# Get your stuff done
project.do_stuff()
Features
--------
- Be awesome
- Make things faster
Installation
------------
Install $project by running:
install project
Contribute
----------
- Issue Tracker: github.com/$project/$project/issues
- Source Code: github.com/$project/$project
Support
-------
If you are having issues, please let us know.
We have a mailing list located at: [email protected]
License
-------
The project is licensed under the BSD license.
And if you want to read more about writing documentation this is a good place to start. I must warn you that if you choose the blue pillow there is a high chance that you will start writing better documentation :).
