Patterns

Factory (Domain)

The Factory pattern is a creational pattern that provides an interface for creating objects but lets subclasses decide which class to instantiate. This promotes loose coupling between the client code and the concrete classes of the objects that need to be created, adhering to the “Don’t repeat …

Bridge

structural GOF

The Bridge pattern is a structural design pattern that lets you split an interface into separate interfaces. This pattern is useful when you want to avoid a tight coupling between an abstraction and its implementation, allowing you to vary them independently. It’s particularly effective when you anticipate that both …

Data Mapper

behavioral ORM

The Data Mapper pattern addresses the impedance mismatch between an object-oriented domain model and a relational database. It acts as a mediator, transferring data between these two representations without exposing the database structure to the domain layer. This separation allows the domain model to evolve …

Sacrificial Architecture

resilience scalability operations

Sacrificial Architecture is a resilience pattern where non-critical components are intentionally designed as single points of failure, allowing them to be quickly replaced or rebuilt in the event of an outage. The goal isn’t to make these components reliable, but to make their failure cheap and fast, protecting …

Config Server

architectural infrastructure microservices

The Config Server pattern centralizes configuration management for distributed systems, particularly microservices. Instead of embedding configuration directly within applications or duplicating it across various deployment environments, a dedicated Config Server acts as a single source of truth. Client applications …

Canary Release

behavioral deployment reliability

The Canary Release pattern is a deployment strategy where a new version of software is rolled out to a small subset of users or servers before being made available to the entire infrastructure. This allows for real-world testing of the new version with minimal impact, enabling teams to detect and address any unforeseen …

Double-Checked Locking

concurrency performance

Double-Checked Locking is a software design pattern used to reduce the overhead of synchronization, specifically when initializing a resource, such as a singleton instance, in a multithreaded environment. It aims to combine the benefits of lazy initialization (delaying resource creation until it’s actually …

Factory Method

creational GOF

The Factory Method pattern is a creational design pattern that provides an interface for creating objects, but lets subclasses decide which class to instantiate. It defines a factory method, an operation that returns an object of a product class. Rather than directly instantiating concrete products, the client code …

Parallel Change

behavioral concurrency

The Parallel Change pattern addresses the challenge of maintaining data consistency across multiple, independent systems when changes need to be applied to all of them simultaneously. Instead of a centralized orchestration, each system applies the change independently and then communicates with the others to reconcile …

Read-Through Cache

behavioral caching

The Read-Through Cache pattern addresses the performance bottleneck of frequent data access from a slow data source (like a database or remote API). It introduces a cache layer that sits between the client and the data source. When a client requests data, the cache is consulted first. If the data is present (a cache …