This was originally a [comment] on the [article] "Some software bloat is OK".
--------------------------------------------------------------------------------

The "development time is more important than performance" motto treats bad
performance as *the* problem with software, when in reality poor performance is
a symptom of growing software complexity. I'm sure each individual coder who
has contributed to software bloat believed that their addition was reasonable.
I'm sure everyone who has advocated for microservices fully believes they are
solving a real-world problem. The issue is that we don't treat complexity as a
problem in-and-of-itself.

In physical disciplines, like mechanical engineering, civil engineering, or
even industrial design, there is a natural push towards simplicity. Each new
revision is slimmer & more unified - more beautiful because it gets closer to
being a perfect object that does exactly what it needs to do, and nothing
extra. But in software, possibly because it's difficult to see into a computer,
we don't have the drive for simplicity. Each new LLVM binary is bigger than the
last, each new HTML spec longer, each new JavaScript framework more abstract,
each new Windows revision more bloated.

The result is that it's hard to do basic things. It's hard to draw to the
screen manually because the graphics standards have grown so complicated &
splintered. So you build a web app, but it's hard to do that from scratch
because the pure JS DOM APIs aren't designed for app design. So you adopt a
framework, which itself is buried under years of cruft and legacy decisions.
This is the situation in many areas of programming: abstractions on top of
abstractions and within abstractions, like some complexity fractal from hell.
Yes, each layer fixes a problem. But all together, they create a new problem.
Some software bloat is OK, but all software bloat is bad.

Security, accessibility, and robustness are great goals, but if we want to
build great software, we can't just tack these features on. We need to solve
the difficult problem of fitting in these requirements without making the
software much more complex. As engineers, we need to build a culture around
being disciplined about simplicity. As humans, we need to support engineering
efforts that aren't bogged down by corporate politics.