Behavioral Patterns

Bulkhead

The Bulkhead pattern isolates parts of an application from each other, preventing failures in one part from cascading and bringing down the entire system. It’s inspired by the compartmentalization of a ship’s hull – if one section is breached, the bulkheads prevent the flooding from spreading to the rest …

Bulkhead Cache

resilience behavioral microservices

The Bulkhead Cache pattern enhances system resilience by isolating a shared, potentially unreliable resource – a cache – from the rest of the application. It achieves this by limiting the number of concurrent requests that can access the cache. If the cache is slow or fails, the bulkhead prevents cascading failures by …

Callback

behavioral concurrency

The Callback pattern is a behavioral design pattern where a function (the callback) is passed as an argument to another function, to be executed at a later point in time. It’s a core concept in event-driven programming and asynchronous operations, allowing components to react to events or the completion of tasks …

Class Table Inheritance

behavioral data modeling

Class Table Inheritance (CTI) is a database schema design pattern used to represent class hierarchies in a relational database. Instead of creating a separate table for each class in the hierarchy, CTI uses a single table for the base class and all its subclasses. The table contains columns for all attributes of all …

Competing Consumers

concurrency behavioral

The Competing Consumers pattern addresses the challenge of parallel processing of work items from a shared queue. Multiple consumers compete for messages in the queue, processing them independently and concurrently. This approach significantly improves throughput and responsiveness, especially when processing time for …

Component-based UI

UI architectural behavioral

Component-based UI is an architectural pattern that structures a user interface as a composition of independent, reusable components. Each component encapsulates its own logic, rendering, and data, and interacts with other components through well-defined interfaces. This approach promotes modularity, maintainability, …

Concrete Table Inheritance

behavioral object-relational

Concrete Table Inheritance is a strategy for implementing inheritance in a relational database where each class in the inheritance hierarchy has its own dedicated table. Unlike Class Table Inheritance (Single Table Inheritance) or Shared Table Inheritance, this approach avoids storing all attributes in a single table …

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 …