Free software is suffering because coders don’t know how to write documentation
thenextweb.com
thenextweb.com
Also, the poll seems a suspect way to support the idea that more documentation is justified; I agree with that idea, and TFA has other arguments supporting the point, but I question the utility of the poll as an argument. Developers would like better documentation of the libraries they are using, but they would. In a Pareto-optimal scenario where exactly the right amount of work was put into documentation, developers would still want better documentation. And I would want a pony.
Too many companies expect technical writers to be as savvy, or more, as their developers, but for lower pay, less respect, and zero political power.
This attitude bleeds through to open source/free software.
You want better documentation? Find a way to compensate people for contributing to it, and that doesn't necessarily mean money. Separate your documentation repository from your code base.
This is not the worst case scenario. Some places will sensationally hire QA/Writers, hailing their importance, and lay them off at the first sign of cost cutting.
Not that that's happened to me.
Hmm, I couldn't disagree more!
<< Too many companies expect technical writers to be as savvy, or more, as their developers, but for lower pay, less respect, and zero political power.
Hmm, I couldn't agree more!
Most OSS projects that expect to receive (and actually get) the attention of users or contributors tend to work harder on better documentation.
Contrived example, I know, but the principle holds: time spent by the developer writing good documentation saves users a lot of time. Most developers, in my experience, do not like to write documentation so they prioritize user's needs below their own discomfort.
Some try to take the lazy way out by going the "I'll let the users create the docs on a Wiki" route. See, for example, the Freeswitch (VoIP server) documentation for just how bad this can be.
A lot of developers do want to write good documentation they just don't know how. In this case what we get are reference guides instead of user manuals. Writing small user manuals for OSS projects is not that hard. The key is to put yourself in the user's shoes. Your user wants to accomplish some task with your software, so, in your manual give them step-by-step instructions for how to accomplish it.
It's like writing an algorithm, except that the instructions will run on wetware. For example, to install the software do A,B,C,etc. To compute the standard deviation of your data do 1,2,3 & 4. Spell everything out, just as would do for the computer--assume nothing (ELI5). Don't just give a list of functions.
Users want code that solves their problem with the least possible investment in time and pain. I'm sure many people reading this have been through the OSS pain cycle: find a library that does what you want, see the sparse documentation, and then brace yourself for the pain of figuring out how in the hell to actually use it.
It's terrible. Leads to tons of random settings all over and cargo-culting adding of variables until something happens to work. It's not uncommon for me to find a "documented" variable in the wiki then search the source and not find that string.
There's also an attitude of "we wrote the code, be happy for that, and maybe you should figure it out and document it hmm?" Which is totally their right - they did a lot of work for free and people have made tons of money off of it. But it's not a really practical attitude for good docs.
I'm guilty of it myself - for mod_managed I wrote some basic docs to get it off the ground but haven't kept them up to date or provided more details.
That's true, although it's worth remembering that the 1,000 hours are other peoples time, not the developer's. It might be quite easy for a busy open-source developer (often working in spare time, already) to think "I've got other things I'd rather be doing".
Also, it's not just 8 hours one time - it's then ongoing maintenance. So you're spending time in order to create even more work for yourself in the future; documentation that doesn't exist doesn't have to be maintained alongside code changes.
We need documentation bounties, or something.
...Are there write ups exploring what "or something" could possibly be? Like futures contracts or options or potentially other risk mitigation practices from the financial world? Something that would help with collaboration and help with getting the timing correct? As in, the best time to have the documentation is at the point, or right before some software becomes "popular". But that seems like the time you are least likely to have enough people contributing to bounties. Is there a way to encourage documentation writing speculators? Is there a way to minimize the bad effects (if any) of winner-take-all bounties in discouraging contributors? That is, for bounties, how do you know if someone isn't already working on the documentation unknown to you, and finishes it (and collects the bounty), one week before you finish your version? And the fear of this prevents people from starting in the first place. Is there a way to make "progress payments" on documentation bounties?
Open source software with a sufficient number of users with a clue sooner or later will have sufficient documentation.
There is a lot of open source software with bad documentation but most of the open source projects have no traction. This is different from commercial software where some of the dead software never was released. Comparing statistics between the two is oranges to apples.
Is this partly due to business practices and emphasis on agility? Where everyone is afraid of investing time documenting systems that are possibly (even though often times unlikely) to change in the near future and a fear of sinking resources into increasing efforts (original documenting effort + modifying documentation effort in future if changes occur)?
On top of the initial investment in documenting up front, all too often when future changes come about the documentation is neglected (often due to pressure form the business, or forgetfulness) in the estimated amount of work to achieve a task. Incorrect documentation is often more costly than no documentation.
Because that would involve caring about (1) the future, or at least (2) the experience of your fellow teammates in tending after your code.
Both of which are highly disdained in such environments.
Let me write the documentation for you! I've created this: https://documentation.agency/ and you can email me so my colleagues and I will write or improve your project's documentation. Added a landing page (like https://picnicss.com/ ) and design if you want it. It is for-profit so far, but if everything goes well I'll start doing some heavily reduced prices for some OSS projects.
If this gets traction I'll use part of my time to contribute back to other Free Software libraries.
Hope it does well.
I routinely curse whoever wrote the "docs" for openCV.
Internal software is probably the worst because there isn't a paying customer in the usual sense of the word so there is no one to send the bill to.
Do technical writers still exist? I could write documentation, in fact I intend to spend three days next week doing just that, but someone who has that as their primary skill would do a better job; unfortunately the company no longer employs such people.
If you are doing thing really standard, point to the standard doc of you build system. But most of the time first think you have to do is to spend days trying to guess how the fuck the project is organized.
If your excuse is that you don't have time to write doc, maybe don't expect a lot of contributors, because guess what maybe they don't have time to guess what you didn't writeh.
So in theory, helping with documentation and fixing that would be a good start for them. But it takes confidence to tell someone, especially when you are a newb, that your documentation is sh*t and that you could help with that.
So if projects are more open for that - and explicitly say that, that they are open and thankful for that(also for beginners) - it could be a huge benefit for everyone ...
My point is, the fact that poor documentation frustrates many people according to a survey does not mean that software developers can't or don't write documentation.
We software developers have this borderline criminal tendency to undervalue work that isn't software development, like writing documentation. I'd say that documentation might be closer to 20% of the work of a project, and developers are usually bad at it (by "bad" I mean "unskilled").
[1] http://www.techrepublic.com/blog/10-things/10-things-you-can...
Eagleson's Law: Any code of your own that you haven't looked at for six or more months, might as well have been written by someone else. (Eagleson is an optimist, the real number is more like three weeks.)
Writing documentation isn't so much a "how" problem, but a "why" problem. Most people writing code in their own time can't be bothered also writing documentation for it.
Writing code is fun (mostly). Writing documentation is not.
Also the webs inability to allow the users to meaningfully interact with documentation - by instantly saying -"This step didnt work" and getting then feedback from so god forsaken irc-channel or mailinglist. There is no real integration of the users ability to contribute to documentation. And wikkis are the worst at this. The tagged syntax, the time wise seperation from the point of usage of the documentation.. it all adds barriers, where there should be none. Documentation should not be added online at some remote site.. documentation should be generated by the user, while he is tryialed & errored in some forgotten config- while he defeats a obsticle - and it should mention those who cleared the path through the djungle as heroes.
This is the answer. Software developers are bad doctors, and bad writers, and bad musicians, ... Why do people expect that software developers should have so many other professional skills? The time when your developer designed, implemented and written content for your corporate web is long gone. But we still expect them to be good technical writers.
In the companies I have worked for, we have technical writers that help to write organized, consistent complete documentation. And it is a full time job.
to cut cost most likely
I mean, not every company has enough work to keep a developer, technical writer or marketer going full time. Especially not if their product range is limited or like an agency they mostly flutter from random project to random project.
Less optimistically... yeah, it's probably just money and resources. A developer who can design a website layout, write documentation and get it ranking in Google is cheaper than four people doing one job each.
'Documentation' covers a wide swath of prose, and therefore makes for an easy target for criticism which is in fact very disparate, despite appearing homogeneous.
That is not to say most projects have good documentation. Writing prose -- specifically, technical writing -- is a skill orthogonal to software development and doesn't necessarily tend to attract the same kinds of individuals.
Writing software, its documentation and its way to interact with the user are three totally different beasts requiring different skill sets: documentation and UIs should be written with people in mind, not algorithms, so better not leave that task to a programmer.
Also, writing documentation and user interfaces isn't seen as k3w1 among coders so it's understandable that people good at writing docs and/or designing UIs are rather doing it for a fee outside the FS/OSS world than because they love it.
by Richard Stallman
https://www.gnu.org/philosophy/open-source-misses-the-point....
For end-user documentation I would agree ; does it still stands for developer documentation?
When I say `man foo`, do not suggest I look elsewhere, please.
Is this actually a problem for you? I'm genuinely curious.
"Man" is only really usable when the pages are a reasonable size. Once they get too big, you end up spending most of your time grepping through it or paging forwards and backwards looking for the section you want. But apparently, gnu-info is an "atrocity". Why? Is it somehow morally wrong to ever try to make something better than "man"?
I'll totally own that I'm reactive to that, but I really do think it's a little thoughtless, and a violation of the Principle of Least Surprise, to direct people elsewhere. I've been burned entirely too many times, trying to put out a fire, checking the man page to confirm I remember some argument or option correctly, and being told I'm looking in the wrong place. It's not that it's "morally wrong" to do that; it's that it introduces friction in a place where that might be — demonstrably has been, given my experience, which I know I'm not alone in having had — particularly painful.
Sometimes, "grepping through the man page" is, in fact, the quickest route to the info you need...
I think historically, there were some bad man pages for GNU projects which just pointed to info, but I haven't seen that happen recently.
I'm not saying "don't even try to improve things", and I think that's a pretty un-generous read of my concern. I'm saying don't break people's expectations. Especially if those expectations might come into play in exigent circumstances, and create friction in a place where the user already has a problem that is far more important to them than whether they're using the output from most flexible documentation tool or not.
Like I said, it sounds like that's improved. If so, I'm glad. But I have specifically been burned, and my time that was wasted was also someone else's money. Given that, a bit of, "Hey, guys? Maybe think about how this choice might affect people?" is, IMO, warranted.
That's exactly what I have a problem with... there's a leap between "this sucks" to "therefore they must not care about how this affects other people" that is not justified. If you want something that fits your expectations of how Unix should work, we already have that, it's BSD and it's constructed with a lot of care not to break users' expectations of how Unix works.
The GNU project has really never had that as a project goal. The whole "GNU's Not Unix" acronym is not just a stab at copyrights, but it's a pretty good summary of their goal to create something which is not Unix but instead better than Unix. I'm not saying that they're doing it the right way, or that they actually are better, but that's their stated goal. Pretty much every GNU tool has some incompatibility with the equivalent Unix tool, and they don't care, because they're not trying to make a copy of Unix. Back in the day this was a problem because people would write shell scripts which would assume GNU userland. You still see it in a lot of packages which say that you have to use GNU Make, GNU Awk, GNU Sed, GNU Bison, etc. instead of the equivalent Unix program.
These pieces of advice have fallen by the wayside since GNU userspace has become the norm, but if you really want the Unix experience instead of the GNU experience, go use BSD.
(I've also just spent my entire workday cleaning up the consequences of someone else's think-o instead of working on my own tasks, some of which have a hard deadline. I'm probably kvetching more than anything. Apologies for the noise.)