SWPatterns.com

Microservices - Ruby

The Microservices pattern structures an application as a collection of loosely coupled, independently deployable services, modeled around a business domain. Each service owns its data and communicates via lightweight mechanisms, often an HTTP resource API. This example demonstrates a simplified order and payment …

N-tier - Ruby

The N-tier pattern organizes an application into distinct layers, each with a specific responsibility. This separation improves maintainability, testability, and scalability. A typical N-tier architecture includes a presentation tier (UI), a business logic tier (services), and a data access tier (repositories).

This …

Client-Server - Ruby

The Client-Server pattern organizes a distributed application into two distinct parts: a server that provides a service or resource, and clients that request and consume that service. This example uses Ruby’s socket library to create a simple TCP-based server and client. The server listens for connections, receives …

Self-contained Systems - Ruby

The Self-Contained System pattern promotes building modular, reusable components that encapsulate all their dependencies. Each system should have a clear interface and minimal external exposure. This fosters independence, simplifies testing, and reduces coupling.

Here, we model a simple EmailService as a self-contained …

Monolith - Ruby

The Monolith pattern represents an architectural style where an application is built as a single, unified unit. All functionalities are tightly coupled and deployed together. This contrasts with microservices, which decompose an application into independently deployable services. This Ruby example showcases a basic …

Microkernel - Ruby

The Microkernel pattern structures an application with a minimal core (the “kernel”) and delegated functionality through plugins or extensions. This promotes modularity, flexibility, and ease of extension without modifying the core. Our Ruby example showcases this by defining a simple Microkernel class that …

Clean Architecture - Ruby

The Clean Architecture pattern aims to create systems independent of frameworks, databases, UI, and external agencies. This is achieved by structuring the application into concentric layers: Entities (core business rules), Use Cases (application-specific logic), Interface Adapters (translate data between layers), and …

Onion Architecture - Ruby

The Onion Architecture aims for loose coupling and high cohesion by organizing code into concentric layers. The innermost layer contains enterprise-wide business rules, completely independent of the outer layers. Moving outwards, we have Domain Models, Infrastructure (databases, UI, etc.), and finally, interfaces …

Hexagonal Architecture - Ruby

The Hexagonal Architecture (also known as Ports and Adapters) aims to create loosely coupled software by separating the core business logic from external concerns like databases, UI, and messaging systems. The core communicates via ports (interfaces), while external systems connect through adapters (implementations of …

Layered Architecture - Ruby

The Layered Architecture pattern organizes an application into distinct layers, each performing a specific role. This promotes separation of concerns and makes the system more maintainable and testable. Common layers include Presentation, Business Logic, and Data Access. Our Ruby example utilizes classes to represent …