Simple and simplistic are two orthogonal concepts.
Simple and simplistic are two orthogonal concepts.
They are two independent axes. Two orthogonal axes never meet: moving along one changes nothing to your position on the other. So a solution can be simple and well done, simplistic and quick, or neither. Confusing them leads to bad decisions, because you pick one solution while believing you picked another.
What does "simple" really mean?
Simple is well done, it's perfect, it's sophisticated, it's pure, it's hard to reach, and it usually takes a lot of effort to get rid of every possible problem.
Making simple things is complex. But they are simple to use and to maintain.
Simple does not mean short. A short program can be very tangled, and a longer program can be simple if it is split cleanly.
Rich Hickey makes a useful distinction in Simple Made Easy. Simple means "not interleaved": each element has one role, one concept, one reason to change. Easy means "close to what you already know". A thing can be easy to pick up and very tangled, or simple to understand and unfamiliar at first sight.
So simple is a property of the design. It does not show up on its own. Someone built it, by separating what has to be separated and keeping together what belongs together. A good sign of simplicity: you can explain the solution in a few sentences, without pointing to ten other places in the code.
Why does simplicity take work?
Frederick Brooks, in No Silver Bullet, separates two kinds of complexity. Essential complexity belongs to the problem itself. Accidental complexity comes from our tools, our choices and our detours. A simple solution keeps the first and removes the second.
So the question to ask is simple: does this complexity belong to the problem, or to our way of solving it? To answer it, you first have to understand the problem. That is why simple is hard. You have to know the question before you cut down the answer.
"Simplicity is the ultimate sophistication." — Leonardo da Vinci. The line says the same thing as "simple is sophisticated": sophisticated does not mean complicated. A sophisticated solution is a solution where every piece has a reason to be there.
Why is simplistic so expensive?
Simplistic is done in a rush, quick and dirty, not necessarily well done, dodging or working around the problems it may cause. In general, it works under certain conditions but can easily confuse its audience.
The mechanism is always the same. The shortcut avoids a hard case instead of handling it. That case comes back later, as a bug, a strange behavior in production or an exception nobody can explain. The code then carries a hidden condition, and every change has to take that condition into account while the code says nothing about it.
Take a function that splits a date on the "/" character and always assumes the day/month/year format. It works as long as the dates arrive in that format. The day a file arrives with another separator or another order, it produces a wrong date without any warning. The shortcut did not fail: it was never designed for the cases it ignored.
Making simplistic things is easy. But they are complex to use and to maintain.
A software based on simplistic principles is a very complex software to maintain. This is not a style flaw. The complexity is there, it is just invisible, and you pay for it at every change.
How do you recognize a simple solution?
Follow these steps before you approve a design:
- Define the problem before the solution. Engineering is about solving problems first, implementing the solution comes next.
- List what can break, and handle it in the design, not in the code.
- Give each element one role.
- Measure complexity in use: how much do you need to know to use it?
- Read the code again like a colleague who sees it for the first time.
✅ A module that does one thing, with a short interface. ❌ A module that does everything, with options that turn on hidden behaviors.
You read the first version at a glance. The second one takes memory and patience, and nobody wants to be the only one who understands it.
The fastest test is still the review. If a colleague has to ask several questions before understanding a function, the design is not simple, even if the code is short.
When is simplistic acceptable?
A simplistic solution can be the right choice. A prototype, a throwaway script or a demo do not need the same rigor as a component that will live for years. Simplistic works under certain conditions, and that is exactly what you need to know.
The rule is simple. Write the conditions in the code or in the documentation. Make the shortcut visible, so the next person knows what it avoids. Remove it as soon as the context changes.
A shortcut you admit costs almost nothing. You know where it is, you know when to remove it and you know who has to do it. The danger does not come from the shortcut. It comes from the silence around it, when people take it for a final solution and nobody questions it.
💡Simple takes work. That work is what makes the software easy to use and to maintain!
Resources and bibliography
- Rich Hickey, Simple Made Easy (Strange Loop, 2011). https://www.infoq.com/presentations/Simple-Made-Easy/
- Frederick P. Brooks Jr., No Silver Bullet — Essence and Accident in Software Engineering (IEEE Computer, 1987, first published 1986). https://ieeexplore.ieee.org/document/1663532
- John Ousterhout, A Philosophy of Software Design (Yaknyam Press, 2018). https://web.stanford.edu/~ouster/cgi-bin/aposd.php
- Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship (Prentice Hall, 2008). https://www.oreilly.com/library/view/clean-code-a/9780136083238/
First published on LinkedIn: the original post
