- Application Scaling: Because successful Web Scale companies enjoy exponential growth, their software also needs to support high horizontal scalability. Sometimes, only parts of the software that are e.g. CPU-intensive or I/O intensive need to be scaled and handled separately (implemented with polyglot programming). Monolithic software works as a whole and is developed in one programming language using a single Tech Stack. To achieve horizontal scaling, the entire application needs to be scaled. In line with that because Monolithic software only supports one programming language, it is not possible to implement one module in another programming language or in another Tech Stack.
- Development Speed: To shorten the time to market, every company today wants to have a rapid feature development. In large, complex, and often multimillion-line Monolithic Applications, adding new features is very slow because such Monolithic Applications provide Developers with a huge Cognitive Burden. The giant Monolithic app module is tightly combined and provides additional challenges to add new features. As a result, adding new features in Monolithic apps is often slow and very expensive.
- Development Scale: Companies often want to streampararize development by hiring more developers to have a competitive edge or to pursue low profits. Developers can’t work independently on a giant, Monolithic codebase, which is tightly combined and often requires extra synchronization, so as not to collide with each other’s work. Adding more developers doesn’t result in more features and sometimes gives fewer features. Similarly, because of the high Cognitive Burden of understanding the entire Monolithic codebase, new employees or new graduates often take a long time to write the first line of productive code. In 2008, I did an interview at a Telecom company in Berlin where the Technical Manager told me with a proud smile that they have millions of lines of C++ codebase and new developers can only write productive code after 3-6 months.
- Release Cycle: Cycle Large Monolithic app releases are often too large and usually 6 months to 2/3 years plus delays of several months to several years due to their size. In modern times, large release cycles often put companies under competitive disadvantage because in this huge release gap, new companies can come and take the market.
- Modularization : In Monolithic Architecture, the boundary between Modules is often the internal interface. As soon as the application grows larger, the boundaries between modules begin to fall apart. As a result, often Modules in Monolithic Architecture are tightly combined instead of the double dictum “Loosely combined, very cohesive”. If we compare the development of Software with society, then Monolithic Modularization is like moralistic, religious rules that we know can not guarantee order and order in society .
- Modernization: Existing successful applications need to be modernized due to many factors (e.g. utilizing modern Hardware, Browser, Network Bandwidth, Tech Stack or Attracting good developers). Modernizing Monolithic applications is often expensive and time consuming because it requires the modernization of the Big Bang of the entire application without disrupting the Service.
To address the complexity of modern software applications, to leverage Cloud Computing, Containerization, DevOps, modern Programming languages and to meet the needs of modern software development (rapid development, horizontal scaling), a new Software Architecture Style emerged in 2012: Microservice Architecture. So, what exactly is Microservice Architecture? There are many definitions of Microservice Architecture and here’s my definition:
Microservice architecture is about deciphering Software Systems into autonomous Units that can be deployed independently and that communicate through a lightweight, agnostic language and together they meet business objectives.
Pictured above, a Monolithic Application is a single unit (closely paired) like a cube. Modular applications such as Rubric Cube that can contain small modules but modules are inseparable and can only be used together. Microservices such as lego cubes made from lego blocks where the blocks are loosely combined, easily separated and all lego blocks are made into one cube.