Simple Is not Simplistic
- "Very often, people confuse simple with simplistic. The nuance is lost on most." Clement Mok.
From the "New Oxford Dictionary Of English":
- simple easily understood or done; presenting no difficulty
- simplistic treating complex issues and problems as if they were much simpler than they really are
We all know that simple software is more maintainable, has fewer bugs, has a longer lifetime, etc., and we always try to implement the simplest solutions we can possibly think of. We also know that many developers often end-up with unmaintainable code very quickly.
In my experience, the most common reason for that is due to lack of understanding of what the real problem than needs to be solved is. In fact, when implementing a new piece of functionality, there are several equally important things to do:
- Understand The requirements--is what the users are asking for what they really need?
- Think about how to fit the functionality into the system cleanly--what parts of the current system need to change, if any, to accommodate it nicely?
- Think about what and how to test--how can I prove that the functionality is implemented correctly? How can I make the tests simple to write and simple to run?
- Given all the above, think about the time necessary to implement it--time is always a major concern in software projects
Unfortunately, many developers think that a "simple" solution is: skim through point (1), and assume that the users actually know what they need; think about point (2) forgetting the "cleanly" bit; skip point (3) altogether; reduce the time at point (4) as much as possible by cutting corners. Far from being simple, that actually is a "simplistic" solution.
When the previous approach is used again and again to implement the various bits of functionality of the system, the net result is an increase of the internal complexity of the system, which will negatively affect maintainability and extensibility, and positively affect the introduction of defects (not to mention the fact that the users will be unhappy because the functionality, almost certainly, will not match their expectations).
Doing the right thing--i.e., deal with all the above points appropriately--in the short term, requires more work, and is a bit more difficult and more time consuming, but, in the medium and long term the system will be easier, and less expensive, to maintain and evolve, and the users (and the developers) will be much happier.
Of course, there may be times when a solution is required very quickly and a clean implementation in a short time is impossible. However, hacking a solution should be a deliberate choice, and the costs--the impact of the accumulated technical debt--have to be weighted against the gains.
As Edward De Bono wrote: "simplicity before understanding is simplistic; simplicity after understanding is simple".
This work is licensed under a Creative Commons Attribution 3
Back to 97 Things Every Programmer Should Know home page