I spend a lot of time working with code that someone else wrote. The code has lots of comments, but they actually do little to improve the understandability of the work. I’m here to provide a concise set of examples to demonstrate the proper way to comment your code so that those who follow will be able to understand it easily and get to work.
These examples are in php, but the principles transcend language.
WRONG:
// get the value of the thing $val = gtv(); |
RIGHT:
$thingValue = getTheValueOfTheThing(); |
WRONG:
// get the value of the thing $val = getTheValueOfTheThing(); |
RIGHT:
$thingValue = getTheValueOfTheThing(); |
Oh so very WRONG:
// Let's get the value of the thing $val = getTheValueOfTheThing(); |
We’re not pals on an adventure here.
RIGHT:
$thingValue = getTheValueOfTheThing(); |
You might have noticed that so far all my examples of the proper way to comment your code don’t have comments at all. They have code that doesn’t need a comment in the first place.
Computer languages are not created to make things easier to understand for the machine, they are to make sets of instructions humans can read that (secondarily) tell the computer what to do. So, if the code syntax is for the benefit of humans, treat it that way.
If you have to write a comment to explain what is going on in your code, you probably wrote it wrong. Or at the very least, if you need to write a comment, it means you’re not finished. I write many comments that start TODO, which my tools recognize and give me as a to-do list.
Stopping to come up with the perfect name for a variable, class, or function is an important part of programming. It’s more than a simple label, it’s an understanding of what that symbol means, and how it works in the system. If you can’t name it, you’re not ready to code it.
There is a special category of comments in code called doc blocks. These are massive comments above every function that robots can harvest to generate documentation. It’s a beautiful idea.
Here’s my world (not a standard doc block format but that’s irrelevant):
/* |-------------------------------------------------------------------------- | @name "doSomething" |-------------------------------------------------------------------------- | @expects "id (int)" |-------------------------------------------------------------------------- | @returns "widget" |-------------------------------------------------------------------------- | @description "returns the widget of the frangipani." |-------------------------------------------------------------------------- */ public function doSomething($id, $otherId) { $frangipani = getFrangipani($id); multiplex($frangipani, $otherId); return $frangipani->widgets(); } |
The difficulty with the above is that the laborious description of what the function does is harmfully wrong. The @expects line says it needs one parameter, when actually it needs two. It says it returns a widget but in fact the function returns an array of widgets. If you were to try to understand the function by the doc block, you would waste a ton of time.
It happens all the time – a programmer changes the code but neglects to update the doc block. And if you’re not using robots to generate documentation, the doc block is useless if you write your code well.
public function getFrangipaniWidgets($id, $multiplexorId) { $frangipani = getFrangipani($id); multiplex($frangipani, $multiplexorId); return $frangipani->widgets(); } |
Doc blocks are a commitment, and if you don’t have a programmer or tech writer personally responsible for their accuracy, the harm they cause will far surpass any potential benefit.
I have only one exception to the “comments indicate where you have more work to do” rule: Don’t try this at home.
public function getFrangipaniWidgets($id, $multiplexorId) { $frangipani = getFrangipani($id); // monoplex causes data rehash, invalidating the frangipani multiplex($frangipani, $multiplexorId); return $frangipani->widgets(); } |
This is useful only when the obvious, simple solution to a problem had a killing flaw that is not obvious. This is a warning sign to the programmer coming after you that you have tried the obvious. Often, when leaving notes like this, and explaining why I did something the hard way, I realize that the easy way would have worked after all. At which point I fix my code and delete the comment. But at least in that case the comment did something useful.
