The Glorification of Software Complexity

I feel like in some ways the software industry has glorified complexity. There are architecture diagrams including as many boxes as possible and people talking about how to add a variety of exotic things to your stack, but none showing how to take one away.

Here’s a short take:

In a software system - it’s easy to add new components to a system, but hard to take one away. New components increase complexity significantly since there are new interactions, access patterns, protocols and consistency problems to work through.

Based on this I think we should avoid adding new boxes to our architecture diagrams as much as possible. We should refactor or redesign existing components in order to fulfil a requirement first before resorting to adding a new component. Conversely, the work put into removing an unnecessary component pays dividends.

I see a lot of teams adding a remote cache, a microservice or a message queue because they’re easy to add and give immediate value. However in most cases you’re robbing from your future self without even saving time in the short term.

That remote cache could’ve been avoided with a better designed data access pattern. The microservice could’ve been avoided with modular application code. And the message queue can usually be avoided without doing much of anything…

Keep your stack simple until you’re forced to add to it.

And the kicker: a simple stack is easier to add a component to when you really need it.

What are your thoughts?