Architecturals - Overview Mapping

Let's start by scoping the architecture of a software product. We propose to divide into two main levels:

  • Solution-Level Architecture – The product-level structure comprising a complete set of services that enable a functional application in the market.
  • Service-Level Architecture – The internal organization and workings of unit applictive services within a solution.

Applicative Solution-Level Architecture

Here the classification of solution-level architectures as they focus on inter-system communication. Note that however, some can be applied at the applicative level within a single applicative service.

Client-Server Architecture

  • Description: Systems where clients make requests to a central server, which processes and returns data.
  • Use Cases: Web applications, mobile applications, distributed systems.

Monolithic Architecture

  • Description: All components of the software are unified in a single codebase.
  • Use Cases: Simple applications, legacy systems, where modularity is not a priority.

Microservices Architecture

  • Description: Applications are divided into independent services that communicate via APIs.
  • Use Cases: Complex applications with distinct business domains, scalable applications.

Event-Driven Architecture

  • Description: The system reacts to events or messages, often using message brokers to decouple components.
  • Use Cases: Real-time applications, systems needing high scalability and responsiveness.

Broker Architecture

  • Description: Uses a central broker to mediate communication between components, which may be clients, servers, or services.
  • Use Cases: Distributed systems requiring centralized coordination, such as enterprise integration patterns or IoT platforms with heterogeneous devices.

Message-Oriented Middleware (MOM) Architecture

  • Description: Centers on asynchronous message passing (via queues or topics) between components using a messaging system.
  • Use Cases: Systems requiring reliable message delivery, such as banking transaction processing or distributed workflows in supply chain management.

Service-Oriented Architecture (SOA)

  • Description: Applications are composed of services that offer reusable functions across different business processes.
  • Use Cases: Large-scale, enterprise environments needing integration across diverse systems.

Serverless Architecture

  • Description: Applications run in cloud functions without managing server infrastructure, scaling automatically.
  • Use Cases: Applications with variable workloads, real-time data processing, microservices.

Peer-to-Peer (P2P) Architecture

  • Description: Systems where each node (peer) has equal responsibility and can act as both client and server.
  • Use Cases: Decentralized applications, file sharing, blockchain.

Space-Based Architecture

  • Description: Distributes data and processing across a "tuple space" or in-memory grid for high scalability and low latency.
  • Use Cases: High-performance applications like real-time trading platforms, gaming servers, or large-scale analytics.

Applicative Service-Level Architecture

Component-Based Architecture

  • Description: Applications are built as a collection of reusable components with encapsulated functionality.
  • Use Cases: User interface-driven applications, modular applications.

Functional Architecture

  • Description: Emphasizes stateless functions and pure functions, often in functional programming languages.
  • Use Cases: Data processing applications, complex calculations, scientific applications.

Intent-Driven Architecture (IDA)

  • Description: Centers design on the desired goals or outcomes rather than specific technical constraints.
  • Use Cases: Systems focusing on aligning business goals with system functionality.

Microkernel (Plug-In) Architecture

  • Description: The system has a core with additional functionality provided by plug-ins or add-ons.
  • Use Cases: Software products with core functionality and extensibility, IDEs, operating systems.

Model-View-Controller (MVC) Architecture

  • Description: Separates application logic (Model), user interface (View), and user interaction (Controller).
  • Use Cases: Web applications, desktop applications with user interfaces.

Model-View-ViewModel (MVVM) Architecture

  • Description: Similar to MVC, with a ViewModel layer to handle data binding in UI frameworks.
  • Use Cases: Desktop and mobile applications, especially with reactive UI frameworks.

Pipeline (or Pipes and Filters) Architecture (Batch Processing)

  • Description: Data flows through a sequence of processing steps (pipeline) for batch or real-time processing.
  • Use Cases: Data processing, ETL (Extract, Transform, Load) processes, analytics systems.

Reactive Architecture

  • Description: Structures the codebase around reactive principles (e.g., responsiveness, resilience, message-driven), using asynchronous data streams and non-blocking operations.
  • Use Cases: High-throughput, real-time applications like streaming services, IoT data processing, or responsive APIs.

Entity-Component-System (ECS) Architecture

  • Description: Organizes code into entities (data containers), components (data attributes), and systems (logic that operates on components).
  • Use Cases: Highly modular applications like game engines, simulation software, or systems requiring dynamic behavior composition.

Blackboard Architecture

  • Description: Organizes the codebase around a shared data structure (the "blackboard") where independent components (knowledge sources) contribute to solving a problem collaboratively.
  • Use Cases: AI-driven applications, expert systems, or collaborative processing systems where components need to share and update data incrementally.

Aspect-Oriented Architecture (AOA)

  • Description: Separates cross-cutting concerns (e.g., logging, security, transactions) into aspects that are woven into the codebase.
  • Use Cases: Applications with pervasive concerns like logging or authentication.

Layered (n-Tier) Architecture

  • Description: The system is divided into layers, with each layer responsible for a specific function (e.g., presentation, business logic, data access).
  • Use Cases: Enterprise applications, traditional web applications.

Onion Architecture

  • Description: An architectural pattern that structures code in layers around a central domain model, with dependencies flowing inward. The core contains business rules, surrounded by application services and infrastructure, promoting separation of concerns and adaptability.
  • Use Cases: Business-critical applications like financial systems or e-commerce platforms.

Domain-Driven Design (DDD)

  • Description: The architecture is based on the business domain, creating models and contexts specific to domain functions.
  • Use Cases: Complex business applications where business rules and processes are core to functionality.

Hexagonal Architecture (Ports and Adapters)

  • Description: Separates the core application logic from external dependencies, using adapters for flexibility.
  • Use Cases: Applications needing flexibility for future integrations or testing independence.

Clean Architecture

  • Description: A system design approach that organizes code into concentric layers with business logic (entities and use cases) at the core, independent of frameworks or external systems.
  • Use Cases: Complex applications requiring high testability and flexibility, such as enterprise systems or microservices.

Layered Event Sourcing and CQRS (LECQRS)

  • Description: Combines CQRS and Event Sourcing with layered organization for separation of concerns.
  • Use Cases: Complex, high-traffic systems requiring event trails and efficient queries.

The above list represent a non comprehensive overview of the most common architectural paradigms used in software development. Each paradigm has its own strengths and weaknesses, and the choice of architecture often depends on the specific requirements of the application, such as scalability, maintainability, and complexity.

Done!

Thanks for reading! We hope this overview helps you understand the various architectural paradigms and their applications in software development. For more detailed explanations, follow the links provided to each specific pattern.