This page is still under construction

This page contains a collection of suggestions for what to think about when writing code-level documentation. The documentation in code falls into two categories, described in separate sections below.

Interface documentation

Interface documentation consists of the header comments for files, classes, and methods. Its purpose is to support abstraction: the creation of reusable modules with simple interfaces that hide complex internals. It should be much easier to use a module than to understand its implementation. The module's documentation describes its interface.

• Interface documentation should be as simple and short as possible. If it becomes long and complicated, it suggests that the module may not have a clean interface, so perhaps you should consider redesigning the module. For methods, put all the interface documentation in the method header, and leave all implementation documentation out of the header: put that in the body instead.
• The purpose of interface documentation is to describe how to use a module. It should not describe the internals of the module (if knowledge of the internals is needed to use a module, it suggests that the module doesn't represent a very clean up structure).
• In writing interface documentation, think about the contract between the module and its users; anything that affects this contract should be documented. One example is ownership of memory: if methods in the module return dynamically allocated memory, who is responsible for eventually freeing the memory? Exceptions are another example.
• Interface documentation should describe not just "what" but also "why". "What" means information such as parameter descriptions, return values, and side effects. "Why" means information such as why this class is needed (what problems does it solve?), and in what situations with this class be used? For methods it's often useful to document the situations under which a particular method should/will be invoked (this is particularly useful for callback methods, which are invoked automatically in response to external events).
• For methods, be sure to document side effects: any way this method could affect the future operation of the system, other than through value(s) returned to the caller.
• In the documentation for a method, use different words from those in the method's name. For example, for a method flushBuffer don't say "Flush the buffer" in the documentation, since that provides no new information. Instead, say something different like "Write the buffer contents to the underlying network connection". This second form also indicates when you might want to use this method.

Implementation documentation

These comments are intended to help developers understand how code works internally. It includes documentation in the bodies of methods plus documentation of member variables in classes, which are usually private.

• Don't repeat what is obvious from the code (e.g. "// Increment i" before the statement i++;; this seems obvious, but it happens a lot).
• Document things that are not obvious from the code, perhaps at a higher level. For example, you might include a short comment before each loop that indicates what each iteration of the loop corresponds to, and, at a high level, what each iteration does:

  // Each iteration of the following loop processes one page, writing it // to swapping store if it is dirty. for {...} { ... }

Overall suggestions

The following suggestions apply to both implementation and interface documentation.

• Be precise. Just a couple of extra words can often make things dramatically clearer. For example, "Address of the first byte to be copied" is more precise than "Source buffer".
• Give units. For example, say "Number of bytes to copy" instead of "Buffer length".