Patterns

Store-and-Forward

The Store-and-Forward pattern is a communication paradigm where an intermediary component receives a complete message from a sender, stores it, and then forwards it to the intended recipient. This decoupling allows the sender and receiver to operate independently, even if they are not simultaneously available. The …

Strangler Fig

behavioral refactoring legacy

The Strangler Fig pattern is a refactoring technique used to incrementally migrate a legacy system to a new architecture. Instead of a risky “big bang” rewrite, the pattern advocates for gradually replacing functionality by building a new system around the old one. As the new system gains more responsibility, the old …

Strategy

behavioral design patterns

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows the algorithm to vary independently from the clients that use it. This pattern avoids conditional complexity and promotes code reusability by defining a consistent interface for various algorithms.

This …

Strategy Registry

behavioral DDD

The Strategy Registry pattern provides a centralized way to manage and access a collection of strategy algorithms. Instead of a client directly holding references to multiple concrete strategy classes, it interacts with a registry that maps keys (often strings or enums) to specific strategies. This promotes loose …

Task Farm

concurrency distributed systems behavioral

The Task Farm pattern distributes work across a pool of worker threads or processes. It decouples the task submission from the task execution, allowing for parallel processing and improved resource utilization. Tasks are typically enqueued and workers pick them up as they become available, executing them independently. …

Timeout

behavioral concurrency

The Timeout pattern addresses the problem of operations that may take an indefinite or excessively long time to complete. It introduces a mechanism to automatically cancel or signal an error when an operation exceeds a predefined duration. This prevents resources from being held indefinitely and improves system …

Twelve-Factor App

architectural best practice web

The Twelve-Factor App is a methodology for building software-as-a-service apps. It’s a set of twelve guiding principles that help developers create portable, scalable, and maintainable applications, especially suited for modern cloud environments. These factors cover aspects like codebase, dependencies, …

Two-Phase Commit

distributed system concurrency reliability

The Two-Phase Commit (2PC) protocol is a distributed algorithm used to ensure atomic commits across multiple transaction participants. In essence, it guarantees that either all participants commit changes to the database or none do, maintaining data consistency in a distributed environment. This is crucially important …

View Store

behavioral frontend DDD

The View Store pattern acts as a mediator between a View (UI) and the underlying application State. It centralizes the logic for preparing data from the State into a ViewModel specifically tailored for the View’s needs. Crucially, it also handles user-generated Events from the View, dispatching them to a Reducer …

Visitor

behavioral GOF

The Visitor pattern allows you to add new operations to a hierarchy of objects without modifying the objects themselves. This is achieved by encapsulating the operations in separate “visitor” classes, which can then traverse the object hierarchy and apply their specific logic to each element. It promotes …