Last month, Jeremy shared some valuable information regarding technical debt on SLDN. In his post, he discussed how omitting pertinent information when you're developing for a project can cause more work to build up in the future. One of the most common areas developers overlook when it comes to technical debt is documentation. This oversight comes in two forms: A complete omission of any documentation and inadequate information when documentation does exist. Simply documenting the functionality of your code is a great start, but the best way to close the information gap and avoid technical debt that stems from documentation (or lack thereof) is to follow four simple rules.
1. Know Your Audience
When we're talking about code, it's safe to say you'll have a fairly technical audience; however, it is important to note the level of understanding your audience has on the code itself. While they should be able to grasp common terms and development concepts, they may be unfamiliar with the functionality you are programming. Because of this, it's a good idea to provide a link to an internal, technical knowledgebase or wiki that will provide in-depth details on the functionality of the technology they'll be working with. We try to use a combination of internal and external references that we think will provide the most knowledge to developers who may be looking at our code. Here's an example of that from our Dns_Domain class:
* @SLDNDocumentation Service Overview <<< EOT * SoftLayer customers have the option of hosting DNS domains on the SoftLayer * name servers. Individual domains hosted on the SoftLayer name servers are * handled through the SoftLayer_Dns_Domain service. * * Domain changes are applied automatically by our nameservers, but changes may * not be received by the other name servers on the Internet for 72 hours after * your change. The SoftLayer_Dns_Domain service does not apply to customers who * run their own nameservers on servers purchased from SoftLayer. * * SoftLayer provides secondary DNS hosting services if you wish to maintain DNS * records on your name server, but have records replicated on SoftLayer's name * servers. Use the service to manage secondary DNS * zones and transfers. * EOT * * @SLDNDocumentation Service External Link http://en.wikipedia.org/wiki/Domain_name_system Domain Name System at Wikipedia * @SLDNDocumentation Service External Link http://tools.ietf.org/html/rfc1035 RFC1035: Domain Names - Implementation and Specification at ietf.org * @SLDNDocumentation Service See Also SoftLayer_Dns_Domain_ResourceRecord * @SLDNDocumentation Service See Also SoftLayer_Dns_Domain_Reverse * @SLDNDocumentation Service See Also SoftLayer_Dns_Secondary *
Enabling the user to learn more about a topic, product, or even a specific call alleviates the need for users to ask multiple questions regarding the "what" or "why" and will also minimize the need for you to explain more basic concepts regarding the technology supported by your code.
2. Be Consistent - Terminology
There are two main areas developers should focus on when it comes to consistency: Formatting and terminology.
Luckily, formatting is pretty simple. Most languages have a set of standards attached to them that extend to the Docblock, which is where the documentation portion of the code normally takes place. Docblocks can be used to provide an overview of the class, identify authors or product owners and provide additional reference to those using the code. The example below uses PHP's standards for documentation tagging and allows users to quickly identify the parameters and return value for the createObject method in the Dns_Domain class:
* * @param string $objectType * @param object $templateObject * * @return SoftLayer_Dns_Domain */ public static function createObject($objectType = __CLASS__, $templateObject)
Keeping consistent when it comes to terminology is a bit more difficult; especially if there have been no standards in place before. As an example, we can look to one of the most common elements of hosting: the server. Some people call this a "box," a "physical instance" or simply "hardware." The server may be a name server, a mail server, a database server or a web server.
If your company has adopted a term, use that term. If they haven't, decide on a term with your coworkers and stick to it. It's important to be as specific as possible in your documentation to avoid any confusion, and when you adopt specific terms in your documentation, you'll also find that this consistency will carry over into conversations and meetings. As a result, training new team members on your code will go more smoothly, and it will be easier for other people to assist in maintaining your code's documentation.
Bonus: It's much easier to search and replace when you only have to search for one term.
3. Forget What You Know About Your Code ... But Only Temporarily
Regardless of the industry, people who write their own documentation tend to omit pertinent information about the topic. When I train technical writers, I use the peanut butter and jelly example: How would you explain the process of making a peanut butter and jelly sandwich? Many would-be instructors omit things that would result in a very poorly made sandwich ... if one could be made at all. If you don't tell the reader to get the jelly from the cupboard, how can they put jelly on the sandwich? It's important to ask yourself when writing, "Is there anything that I take for granted about this piece of code that other users might need or want to know?"
Think about a coding example where a method calls one or more methods automatically in order to do its job or a method acts like another method. In our API, the createObjects method uses the logic of the
createObject method that we just discussed. While some developers may pick up on the connection based on the method's name, it is still important to reference the similarities so they can better understand exactly how the code works. We do this in two ways: First, we state that
createObjects follows the logic of
createObject in the overview. Second, we note that
createObject is a related method. The code below shows exactly how we've implemented this:
* @SLDNDocumentation Service Description Create multiple domains at once. * * @SLDNDocumentation Method Overview <<< EOT * Create multiple domains on the SoftLayer name servers. Each domain record * passed to ''createObjects'' follows the logic in the SoftLayer_Dns_Domain * ''createObject'' method. * EOT * * @SLDNDocumentation Method Associated Method SoftLayer_Dns_Domain::createObject
4. Peer Review
The last rule, and one that should not be skipped, is to always have a peer look over your documentation. There really isn't a lot of depth behind this one. In Development, we try to peer review documentation during the code review process. If new content is written during code changes or additions, developers can add content reviewers, who have the ability to add notes with revisions, suggestions and questions. Once all parties are satisfied with the outcome, we close out the review in the system and the content is updated in the next code release. With peer review of documentation, you'll catch typos, inconsistencies and gaps. It always helps to have a second set of eyes before your content hits its users.
Writing better documentation really is that easy: Know your audience, be consistent, don't take your knowledge for granted, and use the peer review process. I put these four rules into practice every day as a technical writer at SoftLayer, and they make my life so much easier. By following these rules, you'll have better documentation for your users and will hopefully eliminate some of that pesky technical debt.
Go, and create better documentation!