Patterns

Convention over Configuration

Convention over Configuration (CoC) is an architectural and programming philosophy that aims to reduce the number of decisions that developers need to make, gaining simplicity. Instead of developers specifying every configuration detail, the software framework or library provides sensible defaults and requires …

Correlation ID

transversal observability distributed systems

The Correlation ID pattern is a technique used in distributed systems to track a single request as it flows across multiple services. It assigns a unique identifier to each request at its entry point (typically the API Gateway or initial client request) and propagates this identifier throughout all subsequent service …

CQRS

behavioral architectural DDD

CQRS (Command Query Responsibility Segregation) is an architectural pattern that separates read and write operations for a data store. Instead of a single data model and access layer handling both reads and writes, CQRS advocates for using two distinct models: one optimized for handling commands (writes, updates, …

Customer-Supplier

behavioral collaboration

The Customer-Supplier pattern describes a relationship between two components where one component (the Customer) requests service from another component (the Supplier). The Supplier then fulfills those requests. This pattern focuses on collaboration and is often used to decouple components while maintaining a clear …

Dead Letter Queue

behavioral integration messaging

The Dead Letter Queue (DLQ) pattern is a mechanism for handling messages that cannot be processed successfully by a consuming application. Instead of being lost or endlessly retried, these problematic messages are moved to a separate queue – the DLQ – for later investigation and potential reprocessing. This ensures …

Dependency Injection

creational behavioral

Dependency Injection (DI) is a software design pattern that implements the Inversion of Control (IoC) principle for resolving dependencies. Instead of a component creating its dependencies, or directly looking them up, those dependencies are injected into the component. This promotes loose coupling, making the code …

Distributed Tracing

observability behavioral microservices

Distributed tracing is a methodology used to profile and monitor transactions as they flow through a distributed system. Unlike traditional logging and monitoring, which focus on individual service metrics, distributed tracing tracks requests across multiple services, providing insight into the entire end-to-end …

Domain Event

DDD behavioral

The Domain Event pattern is a powerful technique in Domain-Driven Design (DDD) used to represent things that have happened within the domain. Instead of objects directly calling methods on other objects, a Domain Event is raised when a significant state change occurs. Interested parties (handlers) then subscribe to …

Event-Driven Architecture

architectural behavioral integration

Event-Driven Architecture (EDA) is a software architecture paradigm where the flow of an application is determined by events. Instead of a traditional request-response model, components communicate by producing and consuming events. This promotes loose coupling, scalability, and responsiveness. Events represent a …

Extension Object

behavioral object-oriented

The Extension Object pattern addresses the problem of adding functionality to existing classes without modifying their core structure. It achieves this by encapsulating varying behaviors into separate extension classes, which are then passed to the client class to execute specific operations. This promotes the Single …