Code smears: code smells that spread across your codebase
Monday 5 January 2015 21:34
The term "code smells" gives us a handy shorthand for signs that our code might not be especially clean. In my experience, the worst sort of code smell are "code smears": those smells that tend to spread their badness across your codebase, which also makes them more difficult to fix as time goes on. For instance, suppose a function has too many arguments, making it difficult to see the purpose of each argument. That code smell isn't confined to the function definition: it's going to appear every time that the function is called.
Code smells tell us that there's probably room for improvement. Ideally, we'd avoid all code smells, but there often comes a point where our time is better spent elsewhere. Yet not all code smells are created equal. Some code smells can be fixed later with little or no impact on the rest of the codebase: for instance, if I take an extremely long function and break it up into smaller functions that compose together nicely, nobody who calls the function needs to be aware that anything has changed.
On the other hand, some code smells tend to make their presence felt across a codebase:
for instance, if a function takes four boolean arguments,
this leads to somewhat mysterious function calls such as update(true, false, true, true).
Fixing this requires changing everywhere that calls that function.
This task can range from tedious, if the function is called in many places, to impossible, if third parties are calling into our code.
As time goes on, it's likely that there will be more callers of the our function, and so more work to clean it up.
I'd suggest that this second group of code smells is more severe than the first, and therefore deserves the more severe name of code smears.
As a further incentive to avoid code smears moreso than code smells, I've found that code smears are often quicker and easier to fix so long as you do so as soon as they appear. Splitting up a long method can be time-consuming and difficult. Giving a function a better name or grouping together related arguments into a single object can often be accomplished in a couple of minutes provided that the function is only used in one or two places under your control.
Sometimes, it's a good trade-off not to fix a code smell. It's rarely a good trade-off to leave behind a code smear.
Topics: Software design