Why can’t developers KISS?

I’ve heard many developers praise the “Keep It Simple, Stupid” principle in public, but I’m yet to meet one describing the code they work with as “simple”.

One of my favourite posts of all time, the insightful What’s Awful about Building Software, has already covered nicely what complex software feels like and how it affects our lives. So I’m going to assume that you’ve either read it or experienced some of the pains yourself. But having now spent 10 years building software, including the last 3 years building developer-facing products (to try and simplify programming), I wanted to reflect on the reasons why it is so hard in practice to change our code, our tooling, our culture and the status quo.

Below are 10 reasons that made it to my list, in no particular order:

1. we have an ego problem   — developers can have strong opinions about the right way of doing things, and the right way is their way, regardless of how complex others find it
2. we suffer from impostor syndrome — some blame themselves for not being smart enough when they should in fact blame the unnecessary complexity that crept into the code
3. we can be pessimist control freaks — instead of embracing high-level, declarative and automated frameworks, we often prefer the much more complex low-level alternative to remain in full control, just in case we might need this control down the line
4. we’re particularly snobbish about low-code   — those “Enterprise low-code platform” are designed for the “suits” and not for smart people, right? Granted, the vendor lock-in of traditional low-code platforms can be a non-starter, but why isn’t anyone building an open-source platform?
5. complex tools make us feel smart   — think about complex tools such as Kubernetes or Redux with their ~50k stars on GitHub; those are great for large-scale software projects, but you’re not Google, and some of us only use them out of vanity (to feel smart or boost our CVs)
6. we still confuse code with Maths   — yes, good abstractions can be extremely helpful (relational algebra gave us SQL), but there’s nothing simple about functions calling functions calling functions calling functions…
7. we get very attached to our code — we might have learned about all the problems that come with “code ownership”, but deep down, we’re still territorial and tend to push back when anyone suggests to refactor our own code just to make it simpler
8. radical innovation is hard and risky   — how many technical entrepreneurs will dare building disruptive tools to “simplify software” when Microsoft is worth $1T and controls a big chunk of the developer tools industry, including GitHub?
9. developers care, but no one else will — it could really help if non-technical colleagues were contributing to the effort of keeping code simple, but that’s hard in practice. How could a PM or a designer tell the difference between simple code or complex code?
10. it’s all because of Trump and Brexit   — just kidding here, but doesn’t everything boil down to politics at the end? It might help if society started to care a bit more about software transparency. Perhaps the complexity of software should even be regulated one day.

Despite all of the above, I personally remain very optimistic that things will eventually change for the better, simply because software has to become simpler to write and maintain. The need for software and the shortage of developers have never been so acute, the low-code space is booming, and VCs have a renewed appetite for dev tools, thus creating new opportunities.

More importantly, and despite all the aforementioned hurdles, there are still many passionate developers out there shipping new open-source solutions to try and fix the complex mess we’re in. If you’d prefer to look at one of those new solutions (instead of just reading me rant about old problems), please consider giving Prodo a spin and discussing it on Slack!