The style and classification of software architecture

Nanyi's study note, "Introduction to Software Architecture," describes 5 of the most commonly used software architectures:
1. Layered architecture
Known

2. Event-Driven Architecture
Software architecture for communicating through events

Event queue: The entry that receives the event
Dispatcher (event mediator): Distributing different events to different business logic units
Event Channel: The channel of communication between the distributor and the processor
Event Processor: Implement business logic, issue events when processing is complete, trigger next action

Advantages
Distributed asynchronous architecture, high degree of decoupling between event handlers, and good scalability of software
Wide applicability, all types of projects can be used
Good performance due to the asynchronous nature of the event, the software is not easy to produce clogging
Event handlers can be loaded and unloaded independently, easy to deploy

Disadvantages
involves asynchronous programming (considering remote communication, loss of response, etc.), developing a relatively complex
It is difficult to support atomic operations because events involve multiple processors and it is difficult to roll back
Distributed and asynchronous features cause this architecture to be more difficult to test

3. Micro-core Architecture
Also known as the plug-in architecture. Refers to the software's relatively small kernel, the main functions and business logic through the plug-in implementation.

The core (core) typically contains only the minimum functionality that the system is running. Plug-ins are independent of each other, the communication between the plug-ins should be minimized to avoid the problem of interdependence.

Advantages
Good function Extensibility (extensibility), what function is needed, develop a plug-in can
Features are isolated, plug-ins can be loaded and unloaded independently, making it easier to deploy,
High customization, adaptable to different development needs
Can be incrementally developed, gradually increase the function

Disadvantages
Extensibility (scalability), the kernel is usually a standalone unit that is not easily distributed
It is relatively difficult to develop because it involves the communication between the plug-in and the kernel, and the internal plugin registration mechanism

4. Micro-Service Architecture

5. Cloud Architecture
Unclear

This pattern is divided into two main parts: the Processing Unit (processing unit) and the virtual middleware (virtualized middleware).

Processing Unit:
Implementing Business logic

Virtual middleware:
Responsible for communication, maintain sessions, data replication, distributed processing, processing Unit deployment.

The virtual middleware also contains four components:

Message middleware (Messaging Grid): Manage user requests and sessions, and decide which processing unit to assign to when a request comes in.

Data Grid: Data is copied to each processing unit, i.e. data synchronization. Ensure that the same data is obtained for a processing unit.

Processing middleware (processing Grid): optional, if a request involves a different type of processing unit, the middleware is responsible for coordinating the processing Unit

Deployment Middleware (Deployment Manager): Responsible for processing unit startup and shutdown, monitoring load and response time, when the load increases, the new start processing unit, the load is reduced, the processing unit is closed.

But not long ago I read the architect exam textbook, which talked about the architectural style of software, divided into 5 categories:

1. Data Flow style
Sequential execution. Includes batch sequences and pipelines/filters.

2. Call/Return style
The system adopts the mechanism of call and return, in essence, it is a strategy of divide and conquer, the main idea is to decompose the complex large system into several subsystems, reduce the complexity and increase the modifiable nature.
Including
1) Main program/Sub-Program
2) object-oriented style
Objects are interacted with by functions and methods.
3) Hierarchical structure style
The upper layer calls the lower layer.
CS, BS, MVC, MVP all belong to the hierarchical structure.

3. Independent component Style
It is emphasized that each component in the system is a relatively independent individual, and they do not communicate directly to reduce the coupling degree and increase the flexibility. Including:
1) Process Communication
Connecting artifacts via message passing
2) Event Subsystem
An implicit invocation style based on events. The system does not directly call the widget, the component's process is registered to the event, and when the event is triggered, all the artifacts registered in it are executed. Viewer mode.

I think the advantage of the main event system is that the invocation is not directly associated with the call and is decoupled.

4. Virtual Machine style
To build a running environment where the system runs, you can parse and run a custom language and increase the flexibility of the architecture. Including
1) Interpreter
2) Rule-centric

5. Warehouse Style
A central database where independent artifacts are executed around them.
1) database
2) Hypertext System
3) blackboard. The blackboard is equivalent to shared data. The knowledge source interacts with the blackboard.

What is the relationship between the style of software architecture described in the textbook and the 5 commonly used architectures mentioned by Ruan Feng?

In my understanding, software architecture style is the kind of software, and architecture is the structure type of software. There are 5 common architectures that you can try to categorize into the appropriate style:

1. Layered structure – call/return style

2. Event-driven architecture – Standalone component style

3. Micro-core architecture – individual component style

4. Micro-Service Architecture – individual component style

5. Cloud Architecture – Individual component style

This classification is estimated to be wrong and is first written down.