What are the three categories of GoF patterns?

Creational patterns abstract how objects are made (Factory, Builder, Singleton, Prototype, Abstract Factory). Structural patterns compose objects into larger structures (Adapter, Decorator, Facade, Proxy, Composite, Bridge, Flyweight). Behavioral patterns assign responsibilities and manage communication between objects (Observer, Strategy, Command, State, and seven more), for 23 patterns in total.

What is the difference between Strategy and State?

Both swap behavior behind an interface, but their intent differs. Strategy lets a client choose an interchangeable algorithm explicitly, such as a sorting or pricing strategy. State lets an object change its own behavior as its internal state transitions, so it appears to change class — the object, not the client, drives the switch.

When should I reach for a design pattern?

Only when the problem the pattern solves is actually present. Patterns are shared vocabulary for recurring designs, not goals in themselves. Forcing a pattern onto simple code adds indirection without benefit; the SOLID and KISS principles warn against this. Recognize the problem first, then name the pattern.

Is Singleton an anti-pattern?

It is the most criticized GoF pattern because it introduces global state, hides dependencies, and complicates testing. It is fine for genuinely single shared resources like a configuration object, but prefer dependency injection so the single instance is passed in rather than fetched from a global accessor.

What is the difference between Adapter, Facade and Proxy?

All three wrap another object but for different reasons. An Adapter converts one interface into another the client expects. A Facade gives a simple unified entry point to a complex subsystem. A Proxy provides a stand-in with the same interface to control access, add lazy loading, caching, or remote calls.

GoF Design Patterns Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

The Gang of Four book (Gamma, Helm, Johnson, Vlissides, 1994) catalogued 23 reusable solutions to recurring object-oriented design problems. Knowing them gives you a shared vocabulary and a head start on structuring code. This reference lists every pattern with its intent and the situation it addresses.

How it works

The 23 patterns split into three families:

Creational (5) — control object creation: Abstract Factory, Builder, Factory Method, Prototype, Singleton.
Structural (7) — compose objects and classes: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy.
Behavioral (11) — manage algorithms and responsibilities: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor.

For each, read the intent (what it achieves) and the when note (the problem that justifies it). Match the problem first, then apply the pattern.

Example

You need to add logging and compression to a data stream without subclassing every stream type for every combination. That is the Decorator problem: wrap the stream in a LoggingStream, then wrap that in a CompressingStream, each adding one responsibility and forwarding the rest. The combinations multiply at runtime, not through a class explosion.

Notes

Patterns describe relationships and intent, not specific code — the same pattern looks different across languages.
Several patterns overlap by structure but differ by intent (Adapter vs Decorator vs Proxy all wrap an object).
Modern languages bake some patterns in: first-class functions make Strategy and Command lightweight, and iterators are built into most standard libraries.
Over-applying patterns is a smell of its own — see the SOLID, KISS and YAGNI principles for the counterweight.