When doing something, simplicity is something that brings a lot of benefits and should be actively pursued. Take programming as an example. Simplicity makes systems easier to reason about. When you can reason about something, you can more easily optimize it. When you have to think less, you save time, allowing you to focus on other things. You need less resources. This is self evident.

On the flip side, simplicity can be dangerous. You can avoid abstraction by piling code on top of code leading to an exponential explosion of complexity. In this case you sacrifice long-term simplicity for short-term simplicity. The other extreme of this is to start abstracting right away and sacrifice the initial speed of development for possible simplicity gains in the future. Obviously the sweet spot is in the middle. Ne intelligent with your planning, but also don’t plan too much. In my opinion, it’s better to err on the side of short-term simplicity, as it’s always possible to abstract later. Here the basic rule can be to make it work, make it right and them make it fast.

A very important, maybe the most important, part of every problem is to manage complexity. Humans have a limited capacity for complexity, which means there is a certain budget. When it is exceeded, progress halts and becomes very difficult. The way to battle complexity is to strive towards simplicity. This means finding the sweet spot of abstraction. Finding this spot is an extremely valuable skill and contributes heavily to solving a problem.

Patterns of simplicity#

Here are some things I noticed that are good to keep in mind when trying to achieve simplicity.

  • Bare minimum: before starting a project, you should think about the requirements and how you could fulfill them with the minimum amount of external dependencies/components. Reducing the number of components right away increases the initial progress making it more likely that a project will be completed.

  • Scope creep: in a similar vein, before starting a project, you should outline what problem you are solving. Solve just that problem. Avoid doing everything. Always keep the goal in mind when thinking about adding a new component.

  • Infrastructure: improving the compilation and debugging process is a very good way to reduce iteration time and wasted mental work on something that you do very often and can be automated. This also applies to writing and documentation as you no longer have to remember things and can focus more on thinking how to solve the problem. Recalling information is also easier and quicker when it’s written down. This makes errors less common and increases speed.

  • Modularity: if you can split up a complex system into a bunch of simple independent systems, you can reason about these smaller systems independently. This further increases speed.

It becomes clear that simplicity comes in many forms. It can not be achieved by greedily pursuing least effort. Ultimately, experience plays a huge role in this. Learning to find the patterns and using them correctly is an art. Simplicity is not just for programming, it’s for life. Go out and find it.