Why Simplify, The Cost Of Complexity

In a previous post I talked about how to simplify things. But to convince ourselves to do this we need to understand whether it is beneficial or not. What are the costs of unnecessary complexity? And what are the benefits of simplification?

Complexity creeps into many areas of life. Your holiday plans, your relationships and your side projects can all be complex. Your knowledge and understanding of the world can be complex.

Let’s look at an example to extract some shapes of complexity. For argument’s sake let us imagine that you’re building an app in your free time. Complexity can take the shape of messy code. A messy architecture and a messy CI/CD process. At first when you start building the app complexity might be the fastest way to get started. You can just start writing and solve problems as you go. But what you might end up with is code that is not expressing the problems in the simplest ways. Eventually you will probably lack a simple to understand structure, good tests and a focused and streamlined process for CI/CD.

This will make upcoming changes more expensive to make. It will be harder to understand the code you have written. It will be harder to modify it without breaking anything. And the deployment process might be very arduous. This can easily be a 10x difference in time taken.

The inverse of this would be a project where the code is easy to understand. It makes the problem look simple. It has good test coverage and an efficient CI/CD process. You can quickly go in and make a change and be confident that you didn’t break anything.

Let’s assume that in the code example above the effectiveness of development is 10x when the code base is kept simple. This means it should be worth spending up to 10x the quickest possible development time to keep it tidy and to keep simplifying it. A key finding here is that building the thing is just part of the goal. Another part of it should be to simplify, even if it doesn’t change the functionality of the product itself.

The bigger a system becomes (and again, this applies not only to software but to most things in life), the more the complexity scales. It’s multiplicative. Every component in the system that is dependent on one another either benefits from the simplicity of the other, or is made more complex by the complexity of the other. The more components you add the more this is multiplied.

Put another way, the more a component is used, the more it pays to simplify it. And the bigger a system might become, the more it will benefit from simplification. The example above can go above 10x in efficiency difference if the system grows even bigger. There shouldn’t be any limit to how big the difference can become.

What are some things in your life that you believe could benefit from less complexity?

Leave a Reply

Your email address will not be published. Required fields are marked *