I've been following the discussions on ExtremeProgramming and TheSourceCodeIsTheDesign with a lot of interest and I've been trying to reconcile two (opposing?) points of view:
In order to reconcile the need for capturing system knowledge that can't immediately be gleaned from the code with the simplicity of not writing any documentation, I'm trying to foster a new style of documentation in my project team. The guidelines for writing documentation are simple:
This approach also encourages reflection and review - I often write short notes about stuff I've done just to get it clearer in my own mind.
Finally, this approach doesn't preclude the production of the 'traditional' documentation if it is needed. We are about to convert our system to Java at the request of a client. It is important we capture early knowledge about the conversion because the conversion team will grow rapidly ... we will make heavy use of 1-to-1 mentoring but there are going to be times when it isn't possible to have the most experienced convertors available to the less-experienced people. The intention is that we will produce a lot of notes during the early, exploratory phases of the conversion and then refactor the notes into a conversion handbook, for use in the later phases. -- PaulDyson
I really like the distrust notion being at the beginning of everything. Wish, though, there were some way to do something even easier than typing up some document. Anything much more distracting than scribbling onto a card can be too much. Good pointer! -- RonJeffries
Sadly enough, I've been using computers so long that I can no longer read what I've written - typed documents are a must :-) -- PaulDyson
Whenever you feel there is a concept in your work that isn't obvious in the code, write a note about it
I've taken to asking my coders to write the note from a generic viewpoint, asking themselves if that piece of documentation could be written up in a way so it becomes useful for other projects, and this project is just one example of that concept in use.
It follows from this that only those concepts that are worthwhile to carry away from the project are those that deserve documentation, and others are not so deserving. Write patterns, not explanations.
I think there's also a subtle sea change occurring due to this as well - my coders are more often checking online resources for existing documentations of patterns (etc), and in some places a page long documentation has been replaced with a one line "this is implemented as a insert name of concept". -- EricScheid
A few years back, I coined a related principle that I called LoRD: LocalityOfReferenceDocumentation. It tries to combat the "out of sight, out of mind" problem when documenting code and design. I initially wrote it up here, but decided it was large enough to move to its own Wiki page. -- BradAppleton
I found that LiterateProgramming (LP) is the best way to keep documentation in sync with code. Because both are in the same document, it it much easier to update either of them. Some people might consider LiterateProgramming the opposite of LightweightDocumentation. I believe that this really depends on how you use it; nobody is forced to write large amount of documentation just because s/he uses LP. I just wish it would be easier to include pictures into documentation. -- ChristianLindig?
My team has started using TwikiClone for documentation and other communications. Eventually, we'll have to produce heavyweight, hard-to-maintain "real documentation", but during the development process we're putting design decisions and review comments into the wiki. Has anyone else tried this? Did it work? -- KrisJohnson
I'm currently taking part in a seminar about advanced functional programming where questions, discussions, and results are recorded with a WikiClone. Often pages are updated during the seminar by the moderator who also projects them onto a screen. I think this is a very good way of recording decision processes. -- ChristianLindig?
moved here from DocumentationOutsideTheSourceCode
I really like this idea of LightweightDocumentation. I think a lot of the aversion to documentation comes from the cultural baggage associated with it: if it is written down it must/should be true. There is probably some historical baggage too: huge volumes of specification that no one could understand, were always out of date and were an absolute pain to maintain. But it does have its uses to communicate ideas that can't be communicated face-to-face (because the idea's originator is busy, in a different country, working for a different company, or dead ... whatever).
Summarizing some thoughts:
Documentation should...
Basic Documentation
If you just stick to the basics, you are 80% there.