Special cases aren't special enough to break the rules
Published by Beto Dealmeida on
My thoughts on special cases in programming
If you're not familiar with the Zen of Python, by Tim Peters, type
import this on an interpreter:
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
I have a corollary to rule #8:
Every time you fix a bug with an
ifcondition, you're hiding an underlying architectural problem.
When we're working on a problem (or a ticket) it's easy to get tunnel vision, and only see the conditions that make the bug appear. There's an old joke where a person went to the doctor and said:
— Doctor, every time I press my stomach it hurts.
— Then stop doing it!
It's a similar thought process when working on a bug: "when these conditions occur, this will break". That thought is easily translated directly into a solution, going from:
do_something() # breaks if `these_conditions`
if not these_conditions: do_something() # no longer breaks
While this might fix the problem at hand (and close the ticket!), there are a few problems with this:
- It might not fix other related problems. What if the conditions are slightly different, will the code still break?
- It might break expectations, if this part of the code is one of many components of a bigger system. We now have one component that behaves slightly different depending on the input conditions.
- It might hide underlying architectural problems. A good design has to deal with as few special cases as possible. Can the system be redesigned so that the
ifcondition is no longer needed?
Conditions sure have their place in code, but my suggestion is to ask yourself these questions every time you want to add an
if to solve a bug. And remember that special cases usually aren't that special.