Ward Cunningham offers a deep exploration of what "complexity" and "simplicity" truly mean in software development. He distinguishes between "empowering complexity" that helps us grow and "difficulty" that simply blocks progress, defining simplicity as "the shortest path to a solution." When you hit a wall during development, he presents the insight of trying "the simplest thing that could possibly work" instead of aiming for perfection — breaking through mental blocks to move forward.
1. Complexity That Grows Us vs. Difficulty That Frustrates Us
In conversation with Bill Venners, Ward Cunningham first shares his philosophy on simplicity and complexity. He doesn't hate all complexity. In fact, he enjoys complexity that empowers — the kind that challenges him and develops his abilities.
But he's wary of disempowering complexity. Trying to understand this kind of complexity is merely tedious labor that does nothing to improve your abilities. Borrowing a friend's words, Ward draws a clear distinction between "problems" and "difficulties."
"There are problems and there are difficulties. A 'problem' is something you can savor. You can say, 'Hmm, that's an interesting problem. Let me think about it for a moment,' and enjoy the thinking process, because you gain insight when you find the solution.
'Difficulty' is different. Computers are famous for creating difficulties. Difficulty is merely an obstacle blocking your progress. You try this and that, and when you finally get it working, it hasn't taught you anything. Tomorrow the situation will be different again. The effort to make a computer work too often becomes the process of dealing with 'difficulties.'"
What we should resent is complexity that creates "difficulties." The world itself is inherently complex, and that complexity can be beautiful. If understanding and conquering it teaches us something, that complexity has value.
2. Simplicity: The Shortest Path to a Solution
So what is simplicity? Ward defines it as "the shortest path to a solution."
For example, suppose you proved a math problem across 20 pages. Later, someone introduces a new mathematical theory that reduces it to 10 pages. Even though you'd need to learn the new theory, it's a shorter path, so it can be considered "simpler." The same applies to software development.
Working the Program
In software, we try to find the easiest way to get the value of solving a problem. Initially you code what you think is the shortest path, but as you grasp the essence of the problem, you rewrite the code. This process is like repeatedly refining a mathematical proof.
- When you discover a new feature that can reduce 30 lines of code to 15, the code becomes easier to understand.
- This effort to simplify code makes you a more powerful programmer tomorrow.
Stripping Away the Unnecessary
Much of simplicity comes from knowing what matters and what doesn't. Programs often become complex because we obsess over unnecessary details.
For example, if code checking that every argument is within range takes up half the program, it's making the program worse, not better. Of course, "fail fast" — having the program immediately stop when errors occur — is important, but choosing where to check is the art of simplification.
Ward cites Einstein's famous quote to emphasize the balance between simplicity and functionality:
"Einstein said: 'As simple as possible, but no simpler.'
He was responding to criticism that his theories were more complex than Newton's. The model became more complex to explain previously unexplained facts, but it was worth it. He made things as simple as necessary without oversimplifying to the point of undermining the essence."
The simple program we write today may grow more complex tomorrow to handle more features. But we should strive to keep it "as simple as possible again" for tomorrow's needs.
3. When You're Stuck, Code "The Simplest Thing That Could Possibly Work"
Ward Cunningham shares an anecdote from his days working in Smalltalk alongside Kent Beck, the pioneer of Extreme Programming (XP). Smalltalk was so powerful that sometimes coding flowed amazingly well, but other times they'd be completely stuck, unable to move at all.
Whenever that happened, Ward would ask Kent a magical question:
"Kent, what's the simplest thing that could possibly work?"
The Power of the Question: Focusing on the Goal
The core of this question is a shift in thinking.
- Don't worry about who will read the code tomorrow.
- Don't worry about whether it's efficient.
- Don't even worry about whether it will actually work.
Just think about "what's the simplest thing that might work right now."
Once you write some code and get something on the screen, your thinking clarifies. When vague ideas that existed only in your head become concrete code before your eyes, you can finally say, "Ah, now I know what to do next."
A Question, Not a Command
Ward worries about this phrase being corrupted into the imperative: "Do the simplest thing that could possibly work." When it becomes a command, people get stuck analyzing and deliberating — "Is this really the simplest thing?" — making things even more complex.
The original intent was to ask "What might be possible?" — a strategy for getting out of having nothing and putting something, anything, on the screen.
"We're always taught to do as much as possible. Always check exceptions, handle the most general case, print friendly error messages. There's so much to do that there's no room to think.
I say: forget all of that and ask yourself, 'What's the simplest thing that could possibly work?'"
Reducing Cognitive Load
The real value of this approach is reducing the amount of information you need to hold in your head. If you're struggling to decide while thinking about 5 things simultaneously, reduce it to 3. If that's still too much, think about just 1 thing.
Sometimes a brute-force approach like linear search is the answer. Another programmer might later look at it and say, "Why didn't they use binary search here? Are they stupid?" But that simple code was a working solution at the time, and it allowed you to move on to the next step. Plus, simple code has the advantage of being understandable by anyone in one minute!
Conclusion
Ward Cunningham presents simplicity as the most powerful tool for overcoming the feeling of being stuck during development. Most difficulties we face when coding stem from trying to handle too many things perfectly all at once.
If you're paralyzed by complex requirements and a sense of obligation, pause and ask yourself: "What's the simplest thing that could possibly work right now?" That small act of simplicity will be the starting point that breaks through the logjam.