Behavioral Patterns

Dependency Injection

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 …

Feature Toggle

behavioral development release

The Feature Toggle (also known as Feature Flag) pattern allows the modification of application behavior without requiring a deployment. It essentially involves wrapping a section of code within a conditional statement controlled by a toggle. This toggle can be dynamically switched at runtime, enabling or disabling a …

Fire-and-Forget

concurrent behavioral

The Fire-and-Forget pattern is a style of concurrency where a task is submitted to an executor and the calling code does not wait for the task to complete. It’s often used when invoking an asynchronous operation and the result of that operation isn’t immediately needed or is handled elsewhere. Essentially, you …

Flux

architectural behavioral reactive

Flux is an application architecture for managing the state of a web application. It’s commonly used with React and other JavaScript frameworks, but the principles can be applied more broadly. The core idea is unidirectional data flow: data flows in a single direction, making it easier to reason about and debug …

Fork-Join

concurrency behavioral

The Fork-Join pattern is a parallel programming strategy that recursively breaks down a problem into smaller, independent subtasks. These subtasks are then executed concurrently, often on different processors or threads. Finally, the results from these subtasks are combined (joined) to produce the overall solution. …

Future

behavioral asynchronous

The Future pattern encapsulates the result of an asynchronous computation. Instead of blocking the calling thread while waiting for the result, a Future object provides a placeholder. The client can then query the Future for the availability of the result and retrieve it when it’s ready, potentially doing other …