Design patterns refresher

Ensures a class has exactly one instance. Useful for genuinely-singular resources (configuration, in-process registry, logger). Often abused: many "singletons" are really just globals in disguise. Prefer dependency injection for testability.

When to use: when there's a genuine single-shared resource and global access is acceptable.

When to avoid: anywhere you might want to swap implementations (testing, multi-tenancy, etc.).

Creates objects without specifying the concrete class. Caller asks the factory; factory decides which subclass to instantiate.

When to use: when the choice of concrete class depends on runtime state (e.g., VehicleFactory creating Car/Motorcycle/Truck based on input).

classDiagram
    direction LR
    class VehicleFactory {
      +create()
    }
    class Vehicle
    class Car
    class Motorcycle
    class Truck
    VehicleFactory --> Vehicle
    Car ..|> Vehicle
    Motorcycle ..|> Vehicle
    Truck ..|> Vehicle
  

Constructs complex objects step by step. Useful when an object has many parameters and immutability is desired.

Java example: Pizza.builder().withSize("Large").withTopping("Cheese").withTopping("Mushrooms").build().

Treats individual objects and compositions uniformly. The canonical example: a file system. File and Directory both implement FileSystemNode; Directory contains a list of nodes (which may be Files or other Directories).

Adds responsibilities to an object dynamically by wrapping it. Coffee with milk = MilkDecorator(Coffee()); Coffee with milk and sugar = SugarDecorator(MilkDecorator(Coffee())).

Converts an interface to one a client expects. Useful for integrating third-party code with incompatible interfaces.

Provides a unified, simpler interface to a complex subsystem. The "front door" to multiple internal services.

Encapsulates an algorithm in a class; client picks which strategy to use at runtime.

Canonical use: PaymentMethod interface with implementations CardPayment, UpiPayment, etc. Caller passes the desired strategy; behavior varies per call.

classDiagram
    direction LR
    class Context {
      +setStrategy()
      +execute()
    }
    class Strategy {
      +execute()
    }
    class CardPayment
    class UpiPayment
    class WalletPayment
    Context o-- Strategy
    CardPayment ..|> Strategy
    UpiPayment ..|> Strategy
    WalletPayment ..|> Strategy
  

When state in one object (subject) changes, notify all dependents (observers). Subject doesn't know its observers directly — they subscribe.

Canonical use: news feed, event systems, UI updates.

classDiagram
    direction LR
    class Subject {
      +attach()
      +detach()
      +notify()
    }
    class Observer {
      +update()
    }
    class EmailNotifier
    class PushNotifier
    class AuditLogger
    Subject o-- Observer
    EmailNotifier ..|> Observer
    PushNotifier ..|> Observer
    AuditLogger ..|> Observer
  

An object changes behavior when its internal state changes. Each state is a class; transitions are explicit. Used for ATMs, vending machines, traffic lights, network protocols.

Encapsulates a request as an object. Useful for undo/redo, queuing, logging actions.

Pass a request along a chain of handlers; each handler decides whether to handle or pass on. Used in logging frameworks (log levels), middleware (HTTP request pipelines).

Defines the skeleton of an algorithm in a base class; subclasses fill in specific steps. Good when several flows share structure but differ in details.

Provides a way to traverse a collection without exposing its internal structure. Most languages have this baked in (Java's Iterable, Python's __iter__).