History Behind Inefficient Monoliths
Understand the historical reasons behind inefficient monolithic software, including past hardware constraints and development practices. Learn how these legacy approaches contrast with today's need for scalable distributed systems and microservices, preparing you to develop software architectures suited for modern demands.
We'll cover the following...
Tracing the origin
Most of the software projects that are executed nowadays are inefficient. They are slow and complicated, produce defective monoliths, do not meet user’s expectations, and so on.
You might wonder: What is the reason behind these problems? Haven’t we already learned how to build software?
Yes, we have, but times have changed.
When I started writing code, hardware was expensive. Companies used to buy a server that had a “beefed-up” processor and memory capacity. Afterwards, developers wrote code that had to offer as much functionality as possible. Organizations needed an all-in-one solution that had to run on a single powerful machine. If there were not enough resources on a server, an administrator would order additional hardware and connect it to the server machine. There were not many people who used the internet and software, so there was no need to worry about scalability.
The world needed monoliths, and developers learned how to build them. Computers did not know how to talk to each other, and so distribution and integration were not a concern. A single team had to consist of a hundred engineers because there was no other way to work on a shared codebase; they sank in communication overhead and always stepped on each other’s toes. These challenges were the norm back then; software had to work at any price.
Today’s challenges
Nowadays, the situation is entirely different. Servers are so cheap that companies want to automatically scale-out in the cloud, opting in to pay at the end of each month at any amount that ends up in their invoices. In return, there is no need to deal with hardware upgrades anymore. There are so many people using the internet that no single server can handle the load even if a small fraction of those users visit a website.
The only way to handle that load is to scale out since scaling up has shown to reach limits. A single application cannot manage all functions, so companies want to build multiple mini-applications (microservices) that work in a connected, distributed fashion. And thus, we have numerous software development teams, each responsible for independent solutions. Scalable and efficient software development teams, processes, and systems have become a winning factor for leading technology firms.
However, as mentioned before, most of the software projects still employ legacy processes that are not compatible with modern needs. This gap explains the problem of inefficient monoliths. To solve this issue, we need to learn how to develop software that is ready for the future with Effective Software.