Passing Knowledge with Code

As a programmer, sometime or another you will be needed to dig into a legacy system. Whether you’re making changes or maybe trying to rewrite it, you’ll need to understand what’s going on.

One of the biggest problems with legacy systems is that there are few to no people who truly understand that system anymore. The original creators have more than likely moved on leaving you to interpret what variable ‘x’ is supposed to mean.

As you can imagine it can be very time consuming dissecting a system that doesn’t follow modern coding conventions, but we need to understand that the code we write will also someday be a legacy system. Someone is going to inherit the system you are writing right now. So, the question is, are they going to curse you for it or thank you for passing on your knowledge?

Self-Documenting Code

One of the biggest things we can do as programmers is make sure our code describes itself. We can do this by careful naming conventions that describe what our intent is. A variable named ‘x’ gives no context or meaning, but variable ‘numberOfSandwhiches’ describes pretty well what is being stored.

Self-documenting code, while verbose, is the best way to have your code describe what it is doing. It also goes hand in hand with refactoring, or rewriting a piece of logic without changing the contract. For example, lets say we have a code block like this:

if(hunger > 0 && bread > 2 && meat > 1 && lettuce > 0 && tomatoes > 0) {
    sandwich = new Sandwich(bread, meat, lettuce, tomatoes);
    numberOfSandwiches++;
}

At first glance it may not be perfectly clear what’s going on with the large list of ingredients in the if statement. But, the idea of refactoring is to make the code easier to understand so we can make it a little clearer by writing it like this.


if(hunger > 0 && ingredientsAvailable()) {
    sandwich = new Sandwich(bread, meat, lettuce, tomatoes);
    numberOfSandwiches++;
}

Hopefully the refactored code is easier to understand at a glance so that whenever future me, or whoever else is going to be looking at this in the future, can quickly understand the intent.

Comments

There is always a big debate about how many comments are appropriate. Some purists will say that if you need comments your code is not self-documenting enough and needs to be refactored.

I prefer the practical approach. Leave comments if you need to, but make sure they actually communicate meaning and context. People in the future might not have access to the bug tracking tools you use today so comments like ‘// Fixed bug 43453’ are less than useful.

But having said comments are okay, I feel I should also give a warning. If you find yourself leaving a lot of comments that could be a code smell and maybe some refactoring would do your code some good. While comments are useful, most of the code should describe itself.

Conclusion

To close I want to reiterate on the importance of passing your knowledge in your code. You may not realize how much you time you’ll be saving some future programmer by writing good documented code.

To help us remember to do this I recommend using fear-driven development: Always code as if the next person to maintain your code is a homicidal maniac who knows where you live.

Originally Published at http://www.bmchild.com/2015/01/passing-knowledge-with-code.html