Why is software so much less efficient than hardware

While hardware continues to get faster and faster, software seems to degrade. It's logical that we aren't as resourceful with the hardware today as we were in the 80s, because the hardware is so powerful today that we can afford to be lazy with our programming and still have our programs run smoothly. But the weird part is that software seems to degrade more than it should.

If computers have gotten 20 times faster the last 20 years (not an exact number, but you understand the principle), and your programs has become half as fast, the programs have somehow accomplished to get 40 times slower. That can't come from human laziness only. There must be some more powerful force working here. And it seems to be not just one root cause but a mish-mash of several ones that all do their own job as well as reinforce each other.

Short-term business goals
A pretty obvious one, but probably not the biggest cause, is software businesses not really caring about making their programs efficient. If they can make money from an inefficient program they'll do that instead. Not all companies do this, but short-term gains seems to often win over long-term quality when it comes to making money... Software companies don't sell efficient programs, they sell updates, new features, more features (which slowly makes the program bigger and slower) and fixing their own bugs. And if their program has a bug, they can always fix it in the next update... which gives an additional excuse to not make it good right now.

Culture, trends and chance
Still, I don't think most companies actually want their customers to be annoyed by slow programs. It's probably often a side-effect from just having the business focus somewhere else. But don't be afraid, software businesses have many other ways to get inefficient practices. Never doubt a company's ability to make bad decisions, and also never doubt their ability to hop on the latest trend when a new cool word arrives.
Some ideas just happen to appear at a certain time and change the trajectory of a whole space. The fact that the internet accelerated the programming space and all its ideas starting from the 90s and onwards is no coincidence, but the fact that Java and Javascript (slow and inefficient languages) were popular at the time instead of C (fast and efficient language) isn't a natural law. These languages have a certain look that may attract business people while C attracts technical people, but I still think trends happen pretty much randomly. And businesses love to cling onto trendy ideas and praise them just because... just because, I guess.

Pseudo-science and methodologies
The culture of software companies unfortunately caught on to a lot of pseudo-science:y stuff like "clean code" and other methodologies talking about code on such a high level that it starts to disconnect from the physical reality of the hardware it runs on, and ideas aiming to improve the developer's life and not the life of the program's end user. The hardware business hasn't caught on to such ideas, and I still think it's pretty random who ends up following magical lies and who ends up following facts.

These pseudo-science ideas aren't necessarily something only program managers force onto their employees of economical reasons. I say this because people online often talk about managers without technical knowledge being the root cause of inefficient business software, but this goes against the fact that LOTS of programmers - who should be the technically knowledgeable ones - also follow these ideas. Even hobby programmers who obviously have no business incentives for using them do.

"Clean code" and similar methodologies claims to create efficient programs, but really do the opposite. But it looks like the code is good!

Code complexity & organizational bureaucracy
Complexity and bureaucracy aren't unique to programming, but they're especially powerful forces here because of the nature of computers and their programs. A computer application is simply a more complicated tool than a spoon and probably even a car. And while we can laugh at the trendy ideas that businesses cling on to (which you can easily avoid with just some common sense), no one escapes code complexity without a fight.

Complexity comes from unnecessary communication between parts, from keeping backwards-compatibility while adding new features, from not knowing how your code works so that you don't dare to remove anything, etc, etc, etc. It grows naturally, and reinforces itself, and you have to manually and deliberately push back against it. That's why complexity tends to grow more often that it decreases. Complexity isn't the better route to take, but it's the easier one (at least in the short term).

And as soon as you work on a code with multiple people, you'll not only get complexity in your code but also in your organization. It grows in the same way there (people usually hire more people than they fire), and the complexity and inefficiency in an organization also seems to translate to complexity and inefficiency in the code (see Casey Muratori). And you don't have to be a commercial company to experience this, open source projects with many collaborators experience the same complexity, just because they are many people trying to collaborate.

And if you don't see how complexity leads to inefficient programs, just imagine a program that does a thing, then imagine a program that does the same thing but also consists of two parts which need to communicate with each other to make that thing happen. Which program is the most efficient? This is what complexity and bureaucracy do to software. Complexity and bureaucracy aren't new trends in the same way as the above mentioned things, but they certainly work together with all the new software trends to make them even more powerful and damaging.

The Internet
Despite all just mentioned, we have no one to thank more for inefficient software than the Internet. It has lowered the barrier to entry for programming. Before, only the really knowledgeable computer nerds could figure out how to start programming, but now it's easy. This is a good thing, but it has also flooded the online forums with information, opinions and ideas that are very inefficient. High-level languages and easy-to-use frameworks are obviously more popular among beginners than low-level languages, and there are naturally more beginners than advanced programmers, which is why there's so much more talk about this stuff online than about... all the other stuff. You have to wade through miles of high-level programming language forums to even get to the people who program in C and Assembly and actually know how computers work.

The Internet is so big and weird that it's impossible to understate its effect on pretty much all parts of the world, but it's also really hard to understand just how and how much it affects things. I don't think I'm doing a good job describing how the Internet leads to inefficient software, but I'm confident that it does. Because it hasn't just affected the culture of how people learn programming, it has also changed the software culture with quick rushed updates, and the field of web programming has influenced other areas in ways that don't always make sense. Animation systems that make sense on the web seem to have infiltrated themselves into Windows programs, which used to have native menus and buttons that worked like clockwork but which now require lots of power to draw, for some reason. And so on, and so on...

Summary
Summarized, you could say that inefficient software comes from unnecessary complexity. Some complexity is necessary and may even be good, but it tends to grow to excessive levels. And this unnecessary complexity (and some of the necessary as well) in turn comes from improved hardware allowing us to be inefficient and use more resources than necessary (which is often easier than doing the opposite), companies choosing profits over simplicity, organizational bureaucracy and the tendency for code to grow more and more complex, programmers choosing frameworks and quick easy solutions over doing it correctly from scratch, web programming trends, pseudo-science, and more. And complexity is an almost unstoppable force, which has led us to the situation we have today.

But it's culture, mostly on the Internet, with its low barrier to entry that lets amateurs take over, that spreads the problem by making us believe it isn't a problem and that we actually need the complexity. Something with the extreme amount of information and the speed of change on the internet seem to make our understanding of programming skewed. The true facts are buried underneath all the stuff people say. Misinformation isn't unique to programming, but the Internet has always contained unproportionally much content about computers and programming (logically), and I think that's why the misinformation is at such a level here. We have the power to understand complexity and keep it away, with a lot of effort, but when we're constantly overstimulated with ideas about how those objectively inefficient frameworks and programming languages are actually preferable, it's harder to take that step towards efficiency and simplicity.

It's no surprise that big companies catch on the obviously bad ideas, but when so many "normal" people do the same, there's a bigger problem. This is one of the reasons I wanted to write this post - partly to figure out the reason for all the bad software to be able to fix it - but also to show how it's not just business people that catch on to new "buzzwords" and get blinded by their own sight. Everyone follows bad ideas if that's what the culture is right now.

So, how do we solve this? An optimistic answer would be to try to spread a new better programming culture. But personally I'd rather not follow any culture at all. Because there isn't really some ancient unknown wisdom you have to discover to start creating efficient software. You just have to _not_ discover "clean code" and internet forums, and then go on and create things from your own mind, and gain your own knowledge while doing it, and repeat. And also deliberately fight against the natural complexity - learn how it works, when and why it appears and how to stop it, which is also something you learn by doing and not by following advice from people online. You'll have a greater chance at succeeding with this if you work alone, but it's an even more noble fight to tame complexity while working with others, maybe at one of those companies that believe all those weird ideas.

Subscribe to Golden emails