The Art of Simplicity
Table of Contents
- Scalable Software isn't always the goal
- The burdens of complexity
- Going towards the light - simplicity
Hey all! There's a topic on my mind in the last few weeks: Simplicity. It's become a bit of a dirty word in tech. It also means a lot of things to a lot of people. To understand simplicity as I would like to talk about it, let's first talk about Complexity. Specifically, the obsession around "scalable software".
Scalable Software isn't always the goal
Yes, in an ideal world the software we build should scale to a large amount of users. In the real world, building for scale often means building with complexity.
You add more pieces of software to your application. More smart computer science-y abstractions to your code. You create infrastructure that can grow for almost any amount of users (and take your wallet with it).
This isn't a bad thing - if you actually need to accommodate this large amount of users. Most applications don't, and won't for a long time (if ever). One reason for this is the VC-induced hyper-growth obsession. The other is that as developers we often forget that code is mostly impermanent and nearly always changes or needs rewriting over time. In other words, there isn't a one size fits all code solution at all scales - you will rewrite your code eventually.
The burdens of complexity
This is how we get complexity - like when you have monstrous tech & infrastructure to host... 20 users. This complexity is the first problem I encounter with many clients.
Some symptoms of this complexity are:
- Bloated tech infrastructure bills
- Having to hire more developers and consultants without a clear ROI
- Poor developer experience (DX), demotivating your developers and slowing feature development
For me as a techie, the last one is especially important - because it's the part of my job that is most within my control. We can't always control clients, deadlines and so on, but why not be able to enjoy the code we write?
Going towards the light - simplicity
So back to simplicity - how can we define it as a contrast to the problems posed above?
- Using simpler tools and abstractions
- Set coding standards up early and often, and enforce them with code instead of by hand
- Use the best of your tech ecosystem where available, avoiding "not build here syndrome"
- Walk the fine line of high cost managed services and DIYing everything
- Use the "wrong" thing (reasonably), when it serves your customers right now instead of later
This form of simplicity is what I like to focus on in my work. It's not always about using less, but it is definitely about using less of what doesn't serve your needs yet.
What's more, is that neither simplicity or complexity are one-way doors. You can go to each as you need to.
If anyone wants to chat more on how to get back to simplicity, and other tech topics, feel free to reach out!