Design Patterns in Practice

Patterns aren't about Gang of Four trivia. They're a shared vocabulary.

Five principles that make code easier to change.

A class should have one reason to change.

Add behavior without editing working code.

If it looks like a duck but needs batteries, your abstraction is wrong.

Two principles that make testing easy.

Duplication is cheaper than the wrong abstraction.

Why most of my class hierarchies are flat.

The two principles that prevent most over-engineering.

Controlling how objects get created.

Let a method decide which class to instantiate.

Create families of related objects that work together.

Construct complex objects step by step.

The most famous and most misused pattern.

Create new objects by copying an existing one.

Reuse expensive objects instead of recreating them.

DI is just passing dependencies in.

Composing objects into larger structures.

Make a third-party API look like your interface.

One simple entry point to a complex subsystem.

Add behavior by wrapping, not editing.

A stand-in that controls access to the real object.

Treat individual objects and groups the same way.

Separate what something does from how it's done.

Share common state to save memory.

How objects communicate and share responsibilities.

Swap algorithms without changing the caller.

Notify interested parties when something happens.

Turn a request into an object.

Pass a request through a chain of handlers.

Define the skeleton, let subclasses fill the steps.

Replace boolean flags with explicit states.

Traverse collections without exposing their internals.

Objects talk through a mediator instead of each other.

Capture state so you can restore it later.

Add operations to a structure without changing it.

Business rules as composable objects.

A collection-like interface over persistence.

Commit many changes as one transaction.

Where use cases live.

Two ways to connect objects to databases.

Keep your API contract separate from your domain.

Small immutable types that make invalid states impossible.

DDD building blocks for consistent models.

For logic that doesn't belong to one entity.

Let the domain announce what happened.

Protect your model from external messy models.

Make failures explicit in your return types.

Replace null checks with an object that does nothing.

Configuration that's typed, validated and testable.