Monolithicsoftware architectures combine their functional elements in a single, inseparable as well as homogeneous structure. Generally by the software architecture is specified, how individual components of a software are connected with one another and which task ranges they cover in each case.
A monolithic structure does not follow the approach of an explicit organization into subsystems or components. Thus these systems are often strongly bound to resources such as hardware, certain data formats and proprietary interfaces. Client server architectures or generally distributed systems form a contrast to the strictly coupled monolithic architectures. Older mainframe programs or even many DOS and Windows 3.x applications are often based on monolithic software architectures.
Software architectures are generally subject to a great deal of freedom with regard to their design. This led straight in earlier times to software systems, which were not structured as a rule into subsystems or on basis of individual, interacting components. These monolithic structures are still to be found today with accordingly older systems and can be afflicted with a set of disadvantages:
- Software systems are neither maintainable nor extendable, since the parts of this system can be modified and adapted to new conditions only with substantial expenditure.
- Software systems are no longer controllable above a certain size due to the lack of modularization; unpredictable side effects occur when modifications are made.
- Parts of the software system cannot be reused.
- Due to the rigid coupling of parts of the software, they cannot run concurrently, for example, for load balancing on distributed systems.
Software applications integrate at least the following functions:
- The presentation i.e. the provision of an interactive interface for the user by the application
- The application logic, which provides the actual functionality of an application
Function coupling in monolithic architectures
If the functionalities of such an application system were to be mapped in a monolithic software architecture, the individual functions would be tightly coupled and implemented in a centralized manner, and the consequence would be the above-mentioned disadvantages. In contrast, today's modern application architectures are implemented as so-called rich clients and build the said GUI applications on separate components whose interaction is organized via carefully defined interfaces. These are, for example, the typical client-server applications. Overall, there has been a paradigm shift away from monolithic architectures to service-oriented architectures( SOA), which are based on the flexible use of logically self-contained and only loosely coupled services. The SOA architecture is an abstract architectural pattern that provides the basis for the distributed provisioning, discovery, and use of services.
An example of a monolithic architecture of a completely different kind is the kernel of the Linux operating system - here one also speaks quite generally of a monolithic kernel. In Linux, this kernel encapsulates a set of basic functions that are tightly coupled to the machine and other hardware resources. For an abstraction of these dependencies interfaces are defined. Specific extensions and additional modules can then build on the basic functionality thus provided by the kernel.