If you can’t explain it to a six year old, you don’t understand it yourself.

― Albert Einstein

It is highly unlikely Einstein ever said this, like most inspirational quotes you can find littered across the internet. But there is some truth to having to understand something on a deep level to be able to simply and explain it.

I find a lot of things are overly complex in my line of work (IT Security). The reasons can vary. Either it’s due to a lack of “intelligent design”, in other words it is a product of organic growth over time. Features and systems added on top of each other without a defined end goal.

Or it’s complexity for the sake of complexity, often due to a lack of knowledge on a subject. Embarrassingly I find the majority of work done in IT is guessing. Guessing how things should be set up. Guessing how things work, interact or are supposed to function.

It could be argued that reality is complex and few, if anyone, ever have the hard facts. Science is guessing based on observation, economics is guessing based on human behaviour, raising a child is guessing what is “right”.

The difference between all of the above and IT is that we, humans, created the technology. The one rule of computers is that they do exactly what you tell them to do. Nothing else, ever! All behaviour should then be deterministic. And it is, if you know all of the variables. But there is not a single human on earth that can know all the variables even of exactly what happens when you press enter after typing in google.com.

The complexity is just far too high. So we guess. And guessing makes us build overly complex systems due to incorrect assumptions. Or to correct for unexpected behaviours. Behaviours that would be deterministic, if we knew what we were doing.

Which brings us to the mother of all complexity. Abstraction. In 1985, if you wanted a computer to calculate the closest route to the local Sushi restaurant you had to enter the source code yourself. Today you ask Siri, google or Alexa. The computer needs to use the same algorithm and process the same data. But you, as the user, or even the programmer, is far removed from most of the tedious complexity of how.

This is great for productivity and I am personally a big proponent of abstractions. But the complexity increase with each layer of abstraction we add and we need to guess even more.

Maybe there is a balance? Maybe we can abstract things away but still attempt to keep things as simple and elegant as possible when we design them? Maybe we don’t need that extra feature, or that fancy animated interface? Maybe doing just enough to make it complete the task is all we need?

KISS, Keep It Simple, Stupid!

A design philosophy coined by the US Navy in the 60s. Valid then, valid now and will be valid tomorrow.