Erick Santana

Software Architecture Concepts

13 min read

An exhaustive, alphabetically sorted list of software architecture concepts, their creators, brief descriptions, and links to key resources, preferably by the authors.

A

ACID Properties - Theo Härder and Andreas Reuter

Active Record Pattern - Martin Fowler

  • Description: An architectural pattern for accessing data in a database, where each object wraps a row in a database table or view.
  • Link: Active Record (Article by Martin Fowler)

Additive Programming - Chris Hanson and Gerald Jay Sussman

  • Description: A programming style where functionality is added incrementally, allowing for flexible and extensible software design without modifying existing code.
  • Link: Software Design for Flexibility (Book by Hanson and Sussman)

Adapter Pattern - Gang of Four (Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides)

Actor Model - Carl Hewitt, Peter Bishop, Richard Steiger

  • Description: A mathematical model of concurrent computation that treats “actors” as the universal primitives of concurrent digital computation.
  • Link: A Universal Modular ACTOR Formalism (Original paper)

Anti-Corruption Layer (from DDD) - Eric Evans

  • Description: A layer that isolates a domain model from external systems to prevent their influence on the domain design, translating between the two as necessary.
  • Link: Domain-Driven Design Reference (Official reference by Eric Evans)

Aspect-Oriented Programming (AOP) - Gregor Kiczales

  • Description: A programming paradigm that increases modularity by allowing the separation of cross-cutting concerns, such as logging or security.
  • Link: Aspect-Oriented Programming (Original paper)

B

BASE Properties - Eric Brewer (coined term), Dan Pritchett (popularized)

  • Description: An alternative to ACID properties, BASE stands for Basically Available, Soft state, Eventual consistency. It provides a model for designing distributed systems that prefer availability over strong consistency.
  • Link: BASE: An ACID Alternative (Article by Dan Pritchett)

Backend for Frontend (BFF) - Sam Newman

  • Description: Creates separate backend services for specific frontend applications or interfaces, optimizing each for its needs.
  • Link: Pattern: Backends For Frontends (Article by Sam Newman)

Big Ball of Mud - Brian Foote and Joseph Yoder

  • Description: A software system that lacks a perceivable architecture; it’s a haphazardly structured, sprawling, sloppy, spaghetti-code jungle.
  • Link: Big Ball of Mud (Original paper)

Bridge Pattern - Gang of Four

  • Description: Decouples an abstraction from its implementation so that the two can vary independently.
  • Link: Design Patterns Book (Book by the Gang of Four)

Bulkhead Pattern - Michael Nygard

  • Description: Isolates components or services to prevent cascading failures, improving system resilience.
  • Link: Release It! (Book by Michael Nygard)

C

C4 Model - Simon Brown

  • Description: A simple hierarchical way to visualize software architecture using a set of diagrams: Context, Container, Component, and Code.
  • Link: The C4 Model for Software Architecture (Official website by Simon Brown)

CAP Theorem - Eric Brewer

Circuit Breaker Pattern - Michael Nygard

  • Description: Detects failures and encapsulates logic to prevent cascading failures, enhancing system stability.
  • Link: Release It! (Book by Michael Nygard)

Clean Architecture - Robert C. Martin (Uncle Bob)

  • Description: Separates the elements of design into ringed layers with dependencies pointing inwards, promoting separation of concerns.
  • Link: The Clean Architecture (Blog post by Uncle Bob)

Cleanroom Software Engineering - Harlan Mills

  • Description: A software development process intended to produce software with a certifiable level of reliability, using formal methods and statistical quality control.
  • Link: Cleanroom Software Engineering (Paper by Harlan Mills)

Client-Server Architecture - Evolved Concept

  • Description: A network architecture where client devices request resources and services from centralized servers.
  • Link: Client-Server Model (Explanation)

Command Pattern - Gang of Four

  • Description: Encapsulates a request as an object, allowing for parameterization and queuing of requests.
  • Link: Design Patterns Book

Command Query Responsibility Segregation (CQRS) - Greg Young

  • Description: Segregates the read and write operations, using separate models optimized for each, improving scalability.
  • Link: CQRS Documents (Greg Young’s blog)

Communicating Sequential Processes (CSP) - Tony Hoare

  • Description: A formal language for describing patterns of interaction in concurrent systems through message-passing communication.
  • Link: Communicating Sequential Processes (Book by Tony Hoare)

Constraint Satisfaction Problems (CSP) - Evolved Concept

  • Description: Mathematical problems defined as a set of objects whose state must satisfy a number of constraints or limitations.
  • Link: Constraint Satisfaction Problems (Explanation)

D

Data Mapper Pattern - Martin Fowler

  • Description: Separates the in-memory objects from the database, mapping between the two, allowing both to vary independently.
  • Link: Data Mapper (Article by Martin Fowler)

Data Transfer Object (DTO) - Martin Fowler

  • Description: An object that carries data between processes to reduce the number of method calls, often used in remote interfaces.
  • Link: Data Transfer Object (Article by Martin Fowler)

Design by Contract - Bertrand Meyer

  • Description: Designing software by defining formal, precise, and verifiable interface specifications for software components.
  • Link: Object-Oriented Software Construction (Book by Bertrand Meyer)

Dependency Injection (DI) - Martin Fowler (popularized the term)

Dependency Inversion Principle - Robert C. Martin

  • Description: States that high-level modules should not depend on low-level modules; both should depend on abstractions.
  • Link: The Dependency Inversion Principle (Archived article by Uncle Bob)

Design Patterns (Gang of Four Patterns) - Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

Domain-Driven Design (DDD) - Eric Evans

  • Description: An approach to software development that focuses on modeling software to match a domain according to input from domain experts.
  • Link: Domain-Driven Design Reference (Official reference by Eric Evans)

Domain-Specific Languages (DSLs) - Chris Hanson and Gerald Jay Sussman

  • Description: Specialized computer languages focused on a particular aspect of a software system, designed to be expressive in that domain.
  • Link: Software Design for Flexibility (Book)

DRY Principle (Don’t Repeat Yourself) - Andy Hunt and Dave Thomas

  • Description: A principle aiming to reduce repetition of software patterns, replacing them with abstractions or data normalization.
  • Link: The Pragmatic Programmer (Book by Hunt and Thomas)

E

Enterprise Integration Patterns - Gregor Hohpe and Bobby Woolf

  • Description: A catalog of patterns for designing messaging systems within enterprise applications to facilitate integration.
  • Link: Enterprise Integration Patterns (Official website)

Event Sourcing - Martin Fowler and Greg Young

  • Description: Stores state changes as a sequence of events, allowing for full audit trails and state reconstruction.
  • Link: Event Sourcing (Article by Martin Fowler)

Event Storming - Alberto Brandolini

  • Description: A workshop-based method to quickly model complex business domains by focusing on domain events, facilitating collaboration.
  • Link: Event Storming (Official website)

Event-Driven Architecture (EDA) - Evolved Concept

  • Description: Promotes the production, detection, consumption of, and reaction to events, enabling loose coupling.
  • Link: Event-Driven Architecture (Article by Martin Fowler)

Eventual Consistency - Werner Vogels

  • Description: A consistency model used in distributed computing to achieve high availability by allowing data to be temporarily inconsistent.
  • Link: Eventually Consistent (Article by Werner Vogels)

F

Formal Methods in Software Engineering - Evolved Concept

  • Description: Mathematical techniques and tools for specifying, developing, and verifying software and hardware systems to ensure correctness and reliability.
  • Link: Formal Methods Wiki (General resource)

Functional Programming Concepts

Currying - Haskell Curry

  • Description: Transforming a function that takes multiple arguments into a sequence of functions each taking a single argument.
  • Link: Currying in Functional Programming (Paper)

Monads - Philip Wadler (popularized in programming)

  • Description: A design pattern used to handle program side effects in functional programming, encapsulating values along with a context.
  • Link: Monads for Functional Programming (Paper by Philip Wadler)

Higher-Order Functions - Evolved Concept

  • Description: Functions that take other functions as arguments or return them as results, fundamental in functional programming languages.
  • Link: Higher-Order Functions (Explanation)

Immutability - Evolved Concept

Lazy Evaluation - Haskell Community

  • Description: An evaluation strategy which delays the evaluation of an expression until its value is needed.
  • Link: Lazy Evaluation (Explanation)

H

Hillel Wayne’s Contributions to Formal Methods

  • Description: Hillel Wayne advocates for the practical application of formal methods in software engineering, making formal verification techniques accessible to industry practitioners.
  • Link: Hillel Wayne’s Website (Official website)

Hoare Logic - C.A.R. Hoare

Horn Clauses - Alain Colmerauer and Philippe Roussel

  • Description: A special kind of clause used in logic programming, especially in Prolog, representing implications suitable for computation.
  • Link: The Birth of Prolog (Historical paper)

Hexagonal Architecture (Ports and Adapters) - Alistair Cockburn

  • Description: Promotes designing software applications to be loosely coupled and easily testable by isolating the core logic from external factors.
  • Link: Hexagonal Architecture (Official website by Alistair Cockburn)

I

Immutable Infrastructure - Kief Morris

  • Description: An approach where servers or systems are never modified after deployment, ensuring consistency across environments and simplifying deployment.
  • Link: Infrastructure as Code (Book by Kief Morris)

Inversion of Control (IoC) - Michael Mattsson (coined term), Martin Fowler (popularized)

K

KISS Principle (Keep It Simple, Stupid) - Kelly Johnson (Originated in U.S. Navy)

  • Description: States that simplicity should be a key goal in design and unnecessary complexity should be avoided.
  • Link: KISS Principle (Background information)

L

Lambda Calculus - Alonzo Church

Layered Architecture (4+1 View Model) - Philippe Kruchten

Layered Architecture (N-tier Architecture) - Evolved Concept

Layered Architecture (Onion Architecture) - Jeffrey Palermo

  • Description: Places the domain model at the core, with layers wrapping around it, aiming for separation of concerns.
  • Link: The Onion Architecture (Blog series by Jeffrey Palermo)

Logic Programming Concepts

Unification - J. Alan Robinson

Resolution Principle - J. Alan Robinson

  • Description: A rule of inference leading to a refutation-complete theorem-proving technique for first-order logic.
  • Link: [Same as above]

SLD Resolution - Robert Kowalski

  • Description: A refinement of resolution used in logic programming to derive consequences from a set of clauses.
  • Link: Logic for Problem Solving (Book by Robert Kowalski)

M

Micro Frontends - Luca Mezzalira

  • Description: Extends microservices to frontend development, allowing teams to independently develop and deploy UI components.
  • Link: Micro Frontends (Official website)

Microkernel Architecture - Evolved Concept

  • Description: Separates core functionality from extended functionality, promoting plug-in modules for extensibility.
  • Link: Microkernel Architecture Pattern (Article by Mark Richards)

Microservices Architecture - James Lewis and Martin Fowler

  • Description: Structures an application as a collection of loosely coupled services, which implement business capabilities.
  • Link: Microservices (Article by Martin Fowler)

Model-Driven Architecture (MDA) - Object Management Group (OMG)

  • Description: Relies on modeling and model transformations to define the functionality and behavior of a system.
  • Link: Model-Driven Architecture (Official website)

Model Checking - E. Clarke, E. Emerson, and A. Pnueli

  • Description: An automated technique that, given a finite-state model of a system and a formal property, systematically checks whether this property holds for that model.
  • Link: Model Checking (Book by Clarke, Grumberg, and Peled)

Model-View-Controller (MVC) - Trygve Reenskaug

  • Description: Separates an application into three main components: Model (data), View (UI), and Controller (business logic).
  • Link: MVC - XEROX PARC 1978-79 (Original reports by Reenskaug)

Model-View-Presenter (MVP) - Mike Potel

  • Description: Improves the separation of concerns between the user interface and the business logic by introducing a Presenter.
  • Link: MVP Design Pattern (Original paper by Mike Potel)

Model-View-ViewModel (MVVM) - John Gossman

  • Description: Facilitates the separation of the development of the graphical user interface from the business logic or back-end logic.
  • Link: Introduction to Model/View/ViewModel pattern (Archived blog post by John Gossman)

Monitoring Concepts

Observability - Charity Majors and Others

  • Description: A measure of how well internal states of a system can be inferred from its external outputs, crucial for debugging and performance.
  • Link: Observability—A 3-Year Retrospective (Article by Charity Majors)

The RED Method - Tom Wilkie

  • Description: A monitoring approach focused on three key metrics: Rate, Errors, and Duration for microservices.
  • Link: The RED Method (Article by Tom Wilkie)

The USE Method - Brendan Gregg

  • Description: Analyzing system performance by checking Utilization, Saturation, and Errors of resources.
  • Link: The USE Method (Article by Brendan Gregg)

Service Level Objectives (SLOs) - Google SRE Team

  • Description: A target level of reliability for a service, defined to ensure acceptable performance and availability.
  • Link: SRE Book: Service Level Objectives (Chapter from Google’s SRE Book)

Blackbox and Whitebox Monitoring - Evolved Concepts

  • Description: Blackbox monitoring treats the system as a whole without internal insight, while whitebox monitoring uses internal metrics.
  • Link: Blackbox vs Whitebox Monitoring (Article)

S

SMT Solvers (Satisfiability Modulo Theories) - Evolved Concept

  • Description: Tools that decide the satisfiability of logical formulas with respect to combinations of background theories, used in proof automation.
  • Link: Introduction to SMT (Book)

Software Specifications - Evolved Concept

  • Description: Detailed descriptions of software system requirements, including functional and non-functional aspects, serving as a blueprint for development.
  • Link: Writing Good Software Specifications (Article by Hillel Wayne)

T

TLA+ (Temporal Logic of Actions) - Leslie Lamport

  • Description: A formal specification language developed for designing, modeling, documenting, and verifying concurrent and distributed systems.
  • Link: TLA+ Homepage (Official website by Leslie Lamport)

Test-Driven Development (TDD) - Kent Beck

  • Description: A software development process that relies on the repetition of a very short development cycle: write a failing test, make it pass, and refactor.
  • Link: Test-Driven Development: By Example (Book by Kent Beck)

The Twelve-Factor App - Adam Wiggins

  • Description: A methodology for building software-as-a-service apps that use declarative formats for setup automation, aiming for portability and resilience.
  • Link: The Twelve-Factor App (Official website by Adam Wiggins)

Graph View

Backlinks