Catalog

Design Patterns

Time-tested solutions to recurring design problems — explained in plain language with PHP, TypeScript, and Python examples.

Design patterns are the names we give to solutions that keep showing up. You don't memorize them to look smart — you learn them so the next time a problem walks in, you recognize the shape and reach for the move that fits. The catalog below mirrors the classic GoF taxonomy: creational, structural, and behavioral. Each entry takes ~5 minutes to read, opens with a real-world scenario, and ends with the patterns it relates to so you can keep pulling the thread.

Builder

Construct a complex object step-by-step, allowing the same construction process to produce different representations.

Factory Method

Define an interface for creating an object, but let subclasses decide which class to instantiate.

Singleton

Ensure a class has only one instance, and provide a single global point of access to it.

Abstract Factory

Provide an interface for creating *families* of related objects without specifying their concrete classes — so the whole family stays consistent.

Prototype

Create new objects by copying an existing, well-configured prototype rather than constructing from scratch.

Adapter

Convert the interface of an existing class into one your client code expects — so the two can work together without either side changing.

Composite

Compose objects into tree structures so that clients can treat individual objects and groups of objects uniformly.

Facade

Provide a single, simple interface to a complex subsystem — so callers don't have to know about every moving part.

Decorator

Attach additional behavior to an object dynamically by wrapping it in another object that shares the same interface.

Proxy

Provide a stand-in for another object that controls access to it — for lazy loading, authorization, caching, logging, or remote calls.

Bridge

Decouple an abstraction from its implementation so that the two can vary — and grow — independently.

Flyweight

Share common state across many fine-grained objects so the system can scale to numbers a naive design couldn't fit in memory.

Command

Turn a request into a stand-alone object so it can be queued, logged, retried, scheduled, or undone.

Iterator

Walk through the elements of a collection without exposing how the collection is laid out underneath.

Observer

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified automatically.

Strategy

Define a family of algorithms, encapsulate each one, and make them interchangeable so the code that uses them never has to change.

Chain of Responsibility

Pass a request along a chain of handlers — each handler either deals with it or forwards it to the next.

Mediator

Centralize complex communications between related objects through a single coordinator — so the objects don't need to know about each other directly.

Memento

Capture an object's internal state so you can restore it later — without exposing the object's internals to the rest of the system.

State

Allow an object to alter its behavior when its internal state changes — so it appears to change its class.

Template Method

Define the skeleton of an algorithm in a base class, and let subclasses fill in specific steps without changing the algorithm's structure.

Interpreter

Define a representation for a small language's grammar and an interpreter that evaluates sentences in that language.

Visitor

Add new operations across a stable hierarchy of objects without modifying the classes themselves.

notification

Let’s make something great together

Contact me anytime. I can turn your vision into reality.

shape

shape