Monolithic vs Distributed
I actually had to google if it's monolith or monolithic
Every software development project, involves designing the overall structure. In technical terms, this refers to the HLD (High Level Design). In this article, I will provide a simplified overview of the 2 most common software architecture, and a list of considerations on which to adopt for a software project.
Software Architecture
In a coding or related course, you are probably introduced to the idea of modularizing your implementation. This means grouping your code in a way, which collectively serve a single purpose. The definition of “a single purpose”, means the codes can have it’s intended function, be reasonably interpreted, logically.
As the codes are modularized, it implicitly establishes an internal relation between the modules. The modules when needed, is utilized. This can happen within the main flow of the program, or it can be used by other modules. The same heuristic is also applied, when the codes are split into different independent software.
The outlining of the relationship between the modules in a system, is 1 of the aspects a software architecture addresses. This includes how these modules interact with each other. This is in hopes that development can always progress smoothly, and that the software can function effectively to the best of it’s ability.
Opinion: Not exactly an opinion, but Martin Fowler is a big gun in the field of software engineering. He has written an excellent article describing the topic of software architecture: https://martinfowler.com/architecture/
Simplified Overview
As of this writing, there are plenty different types of software architecture. As technology continue to develop, the list is likely to grow. In this article, I will only focus on the generalized type of software architecture, which is monolithic and distributed.
A quick recap, when a software is described as monolithic, it is delivered as a single unit. This is similar to a typical desktop application, which is launched from an executable file. The application may have multiple dependent files, which the software may call them, when a developed function requires the supporting files to achieve it’s intended purpose. Specifically, the part that make these applications monolithic, is that all these assets need to be located, and reachable between each other, within a singular computing system.
A distributed software architecture is a generalized type of software architecture, which involves “splitting” up the modules. The essential difference, compared with a monolithic software, is that the modules can be deployed independently on a separate physical system. In this case, the modules run as their own respective service. The independent nature has a varied value, which in most cases is only truly achieved when set up with other modules, but can also operate alone to deliver part of what the software is intended for. The main beauty of this type of architecture, is it eliminates the single point of failure, which the downtime of a module does not implicate other parts of the system.
Decision Factors
The choice on whether to start building a software with a monolithic or distributed architecture, has several considerations. There are no hard rules to these considerations, and it can be of a certain degree between the 2 types. As a guideline, following are some pointers to assist in making a decision.
Deployment Goals
Essentially, this refers to how the users will utilize the software intended function. It can be a software that is installed into a hardware product, which is usually designed as a monolithic application. But for a software product, it is often a decision between a local software, or a cloud application. A software that functions solely on a computer, is usually monolithic. Cloud application can be monolithic too, but a client-server architecture is a popular starting point amongst architects too, which is a type of distributed architecture.
Potential Scale
Scalability is considered to only be applicable for cloud based software, because there’s a potential to server a massive audience, like Facebook or Instagram. This is a measure of the system ability to handle an extremely high load of traffic, which it is require to support. In this case, it is ideal for the software to be designed with distributed in mind. Compared to the typical desktop applications, only 1 user can interact with the software are a time, which the only consideration is only optimizing the logical operations.
System Complexity
There might be a situation which the software system to be built, is simpler than we thought. This can mean having a limited number of features with no potential further development, which can be monolithic for simplicity. The inverse context is that the software has an immense growth potential, similar to a super-app, which designed with distributed in mind will help with growing the system. Regardless, if it’s monolithic or distributed, it is always ideal to develop your software as modular as possible for better maintainability.
Service Criticality
In any business, the availability of a system runtime is always crucial. But in certain industries, the uptime is much more critical as compared to most sectors, like the financial industry. In this case, it is ideal to have a modular approach for designing the system. This does not mean parts of the system cannot be monolithic, but the emphasis is on the type of risk that can be afforded.
Conclusion
Without a doubt, discussion revolving around software architecture, is a huge and complex topic. This article alone covers only a tiny part of the subject, and a limited guideline on deciding between 2 generalized architecture type. Thus, here are some notes when designing the software architecture type at the start of a project:
Business requirement is 1 of the crucial components, to design a suitable software architecture. This is very context based, and it differs across projects. Always emphasize on planning 1st
The complexity of a distributed architecture increases as there involves more parts, which inherently establishes more relationship between them. Always start simple, and refine as needed
Experience is not the only factor to designing a good software architecture. It involves the right thought process, and attitude to approach the matter at hand