Software architecture describes the comprehensive planning and structuring of a software system. Making key decisions concerning the system's architecture, including the selection of the programming languages, frameworks, libraries, and deployment environments, as well as the general design patterns and guiding principles, is part of this process.
Monolithic architecture:
The complete application is created and delivered as a single unit with this approach. It is simple to use, develop, and deploy, but challenging to scale and manage.
Client-server architecture:
Client and server components make up this architecture. The client is in charge of showing the user interface and contacting the server. The requests are handled by the server, which then replies to the client.
Microservices architecture:
In this architecture, the application is broken down into a collection of small, independent services that communicate with each other through APIs. It is scalable, flexible, and easy to maintain but requires more effort to develop and deploy.
Service-oriented architecture (SOA):
Like the microservices design, this architecture focuses on larger, more complicated services that can be accessed by numerous applications. Although it is made to be very versatile and scalable, an implementation might be challenging.
Event-driven architecture:
The program is made to react to events under this architecture, such as user activities or system events. Although it is scalable, adaptable, and capable of managing complicated workflows, it can be challenging to debug and maintain.
Layered architecture:
The program is separated into logical layers in this architecture, such as display, business logic, and data access. Each layer oversees a distinct set of tasks, and layer-to-layer communication is closely regulated. Although it can be less adaptable than other architectures, it is simple to test and maintain.
Domain-driven design:
This architecture is centered on the domain model of the application and is made to be very flexible and modular. Although it can be challenging to implement, it can lead to solutions that are extremely manageable and scalable.
Clean Architecture:
An emphasis on concern separation, maintainability, and testability defines clean architecture as software architecture. It was first discussed by Uncle Bob himself, Robert C. Martin, in his book Clean Architecture: A Craftsman's Guide to Software Structure and Design.
Onion Architecture:
The goal of Onion Architecture is to build applications that are modular, scalable, and have a distinct separation of concerns. It is also known as "Hexagonal Architecture."
Three-Layer Architecture:
The three independent layers of an application—presentation, application or business logic, and data access—are separated by a software architecture called three-layer architecture, also referred to as three-tier architecture. It is a typical architecture that is used for desktop and web applications.
N-Layer Architecture:
Similar to Three Layer Architecture in terms of software architecture, N-Layer Architecture has extra layers for increased complexity and scalability. The architecture can contain any number of layers, as the name implies, with each layer concentrating on a particular set of issues.
Hexagonal Architecture:
A software architecture called hexagonal, also known as ports and adapters architecture or just hexagonal, emphasizes a distinct division between the domain model and the infrastructure that surrounds it. The architecture is made to be easily adaptable to various delivery systems, including message queues, web services, and user interfaces.
CQRS (Command Query Responsibility Segregation):
The software architectural paradigm known as CQRS (Command Query Responsibility Segregation) divides an application's read and write actions into separate models. It highlights the notion that a system need to have distinct models for processing operations and commands (write operations).
Top comments (0)