This is an AMP version of the article, its original content can be found here.
An Empty Line is a Code Smell
The subject may sound like a joke, but it is not. An empty line, used as a separator of instructions in an object method, is a code smell. Why? In short, because a method should not contain "parts." A method should always do one thing and its functional decomposition should be done by language constructs (for example, new methods), and never by empty lines.
Look at this Java class (it does smell, doesn't it?):
This method first loads the content of the file. Second, it
counts how many lines match the regular expression provided. So why does
grep smell? Because it does two things instead of one—it loads and it greps.
If we make a rule, to avoid empty lines in method bodies, the method will have to be refactored in order to preserve the "separation of concerns" introduced by that empty line:
I believe it is obvious that this new class has methods that are much more cohesive and readable. Now every method is doing exactly one thing, and it's easy to understand which thing it is.
This idea about avoiding empty lines is also applicable to other languages, not just Java/C++/Ruby, etc. For example, this CSS code is definitely begging for refactoring:
The empty line here is telling us (screaming at us, actually) that this
class is too complex and has to be decomposed into two classes:
Unfortunately, using empty lines to separate blocks of code is a very common habit. Moreover, very often I see empty blocks of two or even three lines, which are all playing this evil role of a separator of concerns.
Needless to say, a properly designed class must have just a few public methods and a properly designed method must have up to ten instructions (according to Bob Martin). Empty lines inside methods encourage us to break this awesome rule and turn them into multi-page poems.
Of course, it's easier to just click
enter a few times and continue to
code right in the same method, instead of thinking and refactoring first.
This laziness will eventually lead to code that is hardly maintainable
To prevent this from happening in your projects, stop using empty lines inside methods, completely. Ideally, prohibit them in your automated build. In qulice.com, a static analysis tool we're using in all Java projects, we created a custom Checkstyle check that prohibits empty lines in every method.