Hello friends, since the software was born, they have been developed in many different forms. From black and white games to super apps we use every day like Facebook, Youtube…
So have you ever wondered how people create those apps? How do people design applications with such a large number of users?
In today’s article, I will learn with you the 5 most popular software and system architecture patterns today. Maybe through this article, you will partly imagine how people have created the software that we still use every day ^^
I. 5 common software and system architecture patterns
#first. Layered Architecture
In English, the phrase “N-tier architecture” or “Multi-tiered architecture” is often used to describe a layered architecture.
This is a fairly common design pattern when source code is divided into tiers. Some features of this type of architecture:
+ The outermost layer will be the data receiving layer, data will be transmitted (processed) through the intermediate layers. Finally, after the processing is complete, the data will be saved in the last layer (usually called the data tier – this layer works directly with the database).
+ The simplest that we often see is the 3-tier model (three tiers) including: Presentation Tier, Application Tier and Data Tier.
+ In which Presentation Tier is usually the interface layer, interacting directly with users to receive data. Application Tier is usually the layer that receives data and performs processing of business logic (also known as Business logic tier). The data tier is the layer that interacts with the database.
+ The maintenance process is quite easy because the code is very layered and the layers are completely separate.
+ Simple source code structure, easy to understand for newbies.
+ Source code in the long run will “bulge” according to the size of the project.
+ A large part of the code is sometimes only responsible for transferring data between layers, affecting the performance of the application.
#2. Client – Server
Client – Server model (server – client) is probably not strange to many people anymore. This model consists of a server and multiple clients connected to that server.
Some of the features of this model are:
The client sends a request to the server and waits for a response from the server.
When the server accepts a request from a client, it creates a connection to that client over a secure network protocol (usually https).
There are many applications and services using this model. Typically, it is the service of sending and receiving Email.
The client can access the server’s data resources through secured accesses. This makes it easier to share data when far away.
+ With this model, we are not too dependent on technology because we can use any suitable programming language.
+ The maintenance will be easy for the clear division of client and server responsibilities.
+ The biggest disadvantage can be seen of this model is the load capacity of the server when there are too many requests from different clients.
+ In addition, if this model does not guarantee the security of the transmission, it is easy to steal data.
#3. Model – View – Controller (MVC)
Next we will learn about another very popular software design model, which is the MVC (Model – View – Controller) model.
With this model, we divide it into 3 components: Applications’ data model, Presentation Layer (view) and Controller. The general features of this model are:
+ Users can interact with application data through the view layer. But conversely this layer cannot decide what users do with the data.
The Controller layer stands between the Model and the View. The view layer will listen for events and the controller layer will execute those events. Usually this action will call a function to the model layer and the result will be returned and displayed in the view.
There are many web frameworks that are implementing this model like Spring or Rails. That’s why many applications are still using this model.
+ This model promotes software development because all 3 components view, model, controller are closely related to each other.
+ Because the view layer is only responsible for displaying and transmitting data, it is possible to display many different views to the user (while the data remains constant).
+ UI changes are extremely common for web applications but with the MVC pattern the interface can be customized without affecting
+ Because the 3 components view, model, controller are closely linked and interact with each other, when there is a new class, it will be difficult to integrate.
+ Developers also have to learn many technologies if they want to master this model.
#4. Microservices Architecture
In recent years, with the development of super applications, the concept of Microservices is also known to more people.
Microservices is an architectural model where services are implemented separately, where each service has a main task. These services will often be independent of each other so that when one service fails, the other services will continue to function normally.
For example, when you order a car on a car booking application, you will have to log in, book a car and the system will find the driver closest to you…
If according to the mircoservice model, the login can be separated into a separate service, the car booking can be separated into a separate service…
These services work independently, if the car booking function fails, you can still log in normally, just can’t book the car anymore.
+ Breaking the application into small functions makes the development, testing and maintenance process faster, with fewer errors.
+ Avoiding the fact that when the application “died” the whole system “collapsed”, but instead increased flexibility and independence between functions.
+ Can reuse services in other applications
+ It may consume more hardware resources due to having to build many servers to deploy many small services.
+ The development team will have to use a lot of technology to ensure the system works smoothly, avoiding crashing or overloading.
#5. Event-driven architecture
There are applications where components (functions) work only when there is data processing, and when there is no processing, they do not work.
With this event-driven architecture we can think of mobile applications or desktop applications are designed with this architecture.
With event handling, the application can handle many complex logics
+ This is a good extensibility architecture because if you want to add a new component just add new events for those components.
Having many interrelated functions and components makes testing sometimes difficult.
+ Many different functions sometimes handle the same event, which will lead to an error…
Above are 5 architectural and software design patterns that I find quite popular today. Each design pattern has its own advantages and disadvantages.
In fact, there will be many other application and software designs such as Blackboard, Intercepter, Peer-to-Peer, etc.
When developing an application or building a system, choosing the appropriate design and architecture will help optimize a lot of costs and make it easy to expand later. See you in the next articles.