Balancing complexity

Everything should be made as simple as possible, but not simpler -- Albert Einstein.

Jumping off our discussion of tools, a critical job of our tools is to reduce our cognitive load, which is just a fancy way of saying that they should make our lives easier.

You might think, "Well, duh." But we often tolerate tools that don't live up to their promises: You know exactly what you want to do, but here you are, fighting the shell, the AWS Console, or Rust's borrow checker.

What's happening here is a mismatch between two types of complexity: Intrinsic versus extrinsic.

• Intrinsic complexity is the complexity inherent to the problem. When you have made everything as simple as possible, but not simpler, this is what remains.

• Extrinsic complexity is the complexity of everything else: The complexity of the tools you use to tackle the problem, the complexity of the language used to describe the problem or communicate the solution, and so on.

Our goal in designing almost everything is to reduce extrinsic complexity to zero, and this is where good tools can make all the difference!

The two ways it can go wrong

Einstein's quote at the top hints at two ways we can go wrong:

• We didn't make it as simple as possible because we used an approach that was too complex for the problem:

  • React/Next for a simple landing page.

  • Microservice architecture for an internal tool with a low load and only two maintainers.

  • Scaled Agile Framework (SAFE) for... just about anything 🤷‍♂️.

• We made it simpler than possible:

  • Hand-rolled HTML, CSS, and VanillaJS for a large SaaS product.

  • Non-containerized monolith on an EC2 instance for a high-load application with many moving parts.

  • Rock-and-roll, no-structure team approach for a project with many interlocking dependencies.

Why one or the other of these happens and how to spot and avoid it will be a story for another day.

When it goes right

It feels almost magical when the complexity of your approach matches that of the problem. Anything superfluous melts away and lets the underlying issues crystallize. With no other distractions pulling at your mind, the solution is then much more attainable.

Let's end with another quote which perfectly encapsulates what good design in software, AI, projects, teams etc really means:

Simplicity is the ultimate sophistication -- Leonardo DaVinci