Architecture patterns

1. Layered architecture

This pattern separates a system's components into distinct layers, typically the presentation layer, business logic layer, and data access layer.

For instance, we often see the Model-View-Presenter(MVP) pattern in user interface design.

It is a specialized form of layered architecture.

The primary goal of layered architecture is to promote separation so changes in one layer don't negatively impact others.

 

2. Event-driven architecture

This pattern promotes the production and consumption of events between loosely coupled software components and services.

Components broadcast events when something notable happens, and other components subscribe to specific events they are interested in.

Command Query Responsibility Segregation(CQRS) is a prominent example in this domain.

CQRS

With CQRS, the data write operations(commands) are separated from read operations(queries), and changes are often communicated through events.

This makes the system inherently event-driven.

 

3. Microkernel architecture

 

This pattern emphasizes separating core system functionality into a small microkernel and extended functionality into add-ons or plugins.

An application example is the Eclipse IDE: its core runtime handles the plugin architecture, and features from Java tools to Git integration are delivered as plugins.

 

4. Microservices architecture

This decomposes an application into a collection of small, loosely coupled services.

Each service implements specific business capabilities, contains its own data model, and communicates via APIs.

Netflix, for instance, uses microservices to handle everything from movie recommendations to billing.

This architecture promotes modularization of functionality so services can be developed, deployed, and scaled independently.

It increases agility and allows companies like Netflix to rapidly innovate.

 

5. Monolithic architecture

At its core, a monolithic design sees all components of the application - from data access and business logic to the user interface - bundled together into a single codebase and run as a single unit.

This approach simplifies development and deployment, making it a go-to for many startups and smaller applications.

However, it's worth noting the rise of the 'modular monolith'.

This approach retains the benefits of a single deployable unit but emphasizes clear modular boundaries within the codebase.

This allows for easier maintenance and scalability.

It's a middle ground that offers the simplicity of a monolith while paving the way for potential future transitions to architectures like microservices.

 

 

Reference:ByteByteGo