Design Patterns Course

Welcome to Design Patterns: From Code Smells to Enterprise Architecture Mastery — a mentor-led course built for engineers who want judgment, not flashcards.

Design patterns are not code you copy — they are named structures that crystallize decades of hard-won engineering judgment.

In 1994, four engineers — Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides — published Design Patterns: Elements of Reusable Object-Oriented Software.

Every junior engineer who reads the GoF book wants to apply 23 patterns to their first project.

Code smells are Fowler's term for surface symptoms of deeper design problems.

Change points are the heart of pattern selection.

Pattern selection is where engineers most often lose composure — too many patterns, too many trade-offs, too much taste.

Most OOP refreshers teach the four pillars as definitions.

SOLID is the five-principle discipline that makes object-oriented design tractable at scale.

Single Responsibility sounds obvious and is the most violated principle in practice.

Open/Closed is the principle Strategy, Factory Method, Decorator, and plugin systems implement: add new behavior by extending, not by editing stable code.

Liskov Substitution demands that subtypes honor the base contract.

Interface Segregation splits fat interfaces so clients depend only on methods they use.

Dependency Inversion makes testing and infrastructure swaps possible.

Composition over inheritance is the modern default.

Singleton guarantees exactly one instance of a class per process and exposes a global access point.

The problem with Singleton isn't always "one instance" — that's often correct.

Factory Method moves the decision of which concrete class to create out of the consumer and into a dedicated method.

Abstract Factory produces a family of related objects designed to work together — not one product at a time.

Builder turns long, error-prone constructor calls into readable, validated, step-by-step assembly.

Prototype creates new objects by cloning an existing instance rather than calling a constructor.

Object Pool caps expensive resources alive at once and amortises construction cost.

Dependency Injection vs Singleton clarifies an common confusion: DI and Singleton solve overlapping but distinct problems.

Adapter (Wrapper) bridges two incompatible interfaces.

Facade hides complexity of a multi-class subsystem behind a small, purpose-built API.

Decorator wraps an object that shares its interface and adds behaviour before/after delegating to the original.

Proxy stands in for a real object and intercepts every call — same interface, different responsibilities.

Composite lets a single object and a group share the same interface, so callers recurse a tree without caring whether a node is leaf or branch.

Bridge splits one class hierarchy into two independent axes: abstraction (what the client uses) and implementation (how work is done).

Flyweight reduces memory by sharing one immutable instance among many logical objects.

Structural Patterns in Microservices maps GoF structural patterns onto network boundaries.

Strategy turns a conditional that selects an algorithm into a polymorphic call.

Observer (Publish/Subscribe at object level) decouples event sources from handlers.

Command turns a method call into a first-class object you can store, queue, schedule, undo, log, or replay.

State models a context that behaves differently depending on which state object it holds.

Template Method fixes the order of a multi-step algorithm in a base class and lets subclasses override variable steps.

Iterator separates traversal from storage.

Chain of Responsibility arranges handlers in sequence; each handles the request or passes to next.

Mediator centralises conversation between colleagues.

Memento powers undo, snapshotting, checkpointing, and save-game.

Visitor separates algorithms from the structures they operate on.

Behavioral Patterns in Event Systems composes Observer, Command, State, Mediator, and Chain of Responsibility into coherent event-driven architecture.

Layered Architecture stacks the application in horizontal layers — presentation, application, domain, infrastructure — each depending only on layers below.

Hexagonal Architecture (Ports and Adapters) puts domain at the center.

Clean Architecture (Uncle Bob) codifies concentric layers: Entities → Use Cases → Interface Adapters → Frameworks.

Repository mediates between domain and persistence with a collection-like interface: findById, save, delete — without exposing SQL, ORM, or table shapes.

Unit of Work tracks changes to multiple aggregates during a business transaction and commits them atomically.

CQRS (Command Query Responsibility Segregation) separates write model (commands, normalized, strict) from read model (queries, denormalized, fast).

Event Sourcing persists state as a sequence of state-changing events — not current row snapshot.

Saga manages distributed transactions as a sequence of local transactions with compensating actions on failure.

Outbox Pattern solves the dual-write problem: atomically persist business data and outgoing message in the same database transaction, then a relay process publishes to Kafka/SNS.

Circuit Breaker stops cascading failures when a downstream dependency is unhealthy.

API Gateway is the single entry point for clients into microservices — routing, authentication, rate limiting, TLS termination, and request shaping.

BFF (Backend for Frontend) provides a dedicated backend per client channel — mobile, web, partner — that aggregates microservices into the exact shape each frontend needs.

Strangler Fig gradually replaces a legacy system by intercepting traffic at the edge — new routes go to the new system, unmatched routes fall through to legacy.

Refactoring to Patterns (Joshua Kerievsky, 2004) inverts the GoF approach.

When NOT to use a pattern is the most under-taught topic in design patterns.

Pattern overengineering is the senior tax on junior enthusiasm: every new wrapped in Factory, every interface with one implementation, 8-layer stacks before CRUD hits the database.

Testing pattern-based code reveals whether patterns helped or hurt.

Patterns in legacy codebases is where seniors earn their keep: no tests, tangled dependencies, original authors gone, business can't stop shipping.

Design patterns interviews at senior levels test judgment, not memorization.

System design + patterns is the layer above GoF: how patterns compose in distributed systems.

Mock interview: creational simulates a 45-minute senior loop on object-creation patterns.

Mock interview: behavioral focuses on collaboration patterns.

Pattern vocabulary cheat sheet — print, fold, review before senior interviews.

E-commerce checkout is the canonical capstone — pricing, inventory, payment, fulfilment, notification, audit.

Notification system design tests Strategy + Factory + Observer + Outbox composition.

Payment gateway integration is highest-stakes pattern composition: money involved, partial failures unacceptable, vendor SDKs inconsistent, regional providers need fallbacks.

Multi-tenant SaaS requires tenant-aware routing, auth, data, config, billing, audit.

Final capstone review closes the course tying every lesson together.