SWPatterns.com

Master-Slave - Ruby

The Master-Slave pattern distributes work to multiple worker nodes (slaves) from a central coordinator (master). The master assigns tasks, and slaves execute them independently, reporting results back to the master. This boosts performance through parallelization. This Ruby implementation uses threads for the slaves …

Publish-Subscribe - Ruby

The Publish-Subscribe (Pub/Sub) pattern decouples message senders (publishers) from message receivers (subscribers). Publishers don’t know who is receiving messages, and subscribers don’t need to know where messages come from. A central message broker (in this case, a simple Ruby hash) manages subscriptions.

This Ruby …

Blackboard - Ruby

The Blackboard pattern is a computational architecture for solving problems that can’t be solved with a deterministic algorithm. It consists of several knowledge sources (independent modules) that contribute to solving a problem by observing a shared data structure – the “blackboard”. These sources react to changes on …

Pipes and Filters - Ruby

The Pipes and Filters pattern consists of processing stages (filters) connected by channels (pipes). Each filter performs a specific transformation on the data, and passes the result to the next filter via the pipe. This promotes modularity, reusability, and simplifies complex processing pipelines.

The Ruby code …

Cluster-based Architecture - Ruby

The Cluster-based Architecture pattern distributes workload across multiple identical nodes (clusters) to improve performance, scalability, and fault tolerance. Each cluster handles a subset of the overall task. This example simulates a simple web request processing system with three clusters. A RequestDistributor …

Shared-Nothing - Ruby

The Shared-Nothing architecture aims for scalability and fault tolerance by distributing the entire dataset across multiple independent nodes, each with its own dedicated resources (CPU, memory, disk). Nodes communicate via messaging, avoiding shared memory or centralized coordination. This Ruby example simulates a …

Message Broker - Ruby

The Message Broker pattern decouples application components by allowing them to communicate via messages, without direct dependencies. A central message broker receives messages from publishers and routes them to appropriate subscribers. This promotes scalability, flexibility, and fault tolerance. My Ruby …

Space-Based Architecture - Ruby

The Space-Based Architecture pattern organizes code into loosely coupled, independent modules (“spaces”) that communicate via a central “space” or message bus. This promotes modularity and allows components to be added, removed, or modified without impacting others. Our Ruby implementation uses …

Event-Driven Architecture - Ruby

The Event-Driven Architecture (EDA) decouples components by allowing them to communicate through events. Components (event producers) emit events without knowing who will handle them, and other components (event consumers) subscribe to events they’re interested in. This promotes scalability and flexibility.

This …

SOA - Ruby

The Service-Oriented Architecture (SOA) pattern structures an application as a collection of loosely coupled, interoperable services. Each service encapsulates a specific business function and communicates with others through well-defined interfaces (often APIs). This promotes modularity, reusability, and independent …