GoF Design Patterns Reference
A comprehensive reference for the Gang of Four design patterns. This skill provides language-agnostic guidance with pseudocode examples that can be translated to any programming language.
When This Skill Activates
This skill automatically activates when you:
- Ask about or need to implement a design pattern
- Need to choose between patterns for a design problem
- Are refactoring code and considering structural improvements
- Discuss architecture, decoupling, or extensibility
- Mention specific patterns: factory, singleton, observer, decorator, etc.
Quick Pattern Reference
Creational Patterns (Object Creation)
| Pattern |
Intent |
Use When |
| Abstract Factory |
Create families of related objects |
Need platform/theme independence |
| Builder |
Construct complex objects step-by-step |
Object has many optional parts |
| Factory Method |
Let subclasses decide which class to instantiate |
Don't know concrete types ahead of time |
| Prototype |
Clone existing objects |
Object creation is expensive |
| Singleton |
Ensure single instance |
Need exactly one shared instance |
Structural Patterns (Composition)
| Pattern |
Intent |
Use When |
| Adapter |
Convert interface to expected interface |
Integrating incompatible interfaces |
| Bridge |
Separate abstraction from implementation |
Need to vary both independently |
| Composite |
Treat individual and groups uniformly |
Have tree structures |
| Decorator |
Add responsibilities dynamically |
Need flexible extension |
| Facade |
Simplified interface to subsystem |
Complex subsystem needs simple API |
| Flyweight |
Share common state efficiently |
Many similar objects needed |
| Proxy |
Control access to object |
Need lazy loading, access control, logging |
Behavioral Patterns (Communication)
| Pattern |
Intent |
Use When |
| Chain of Responsibility |
Pass request along handler chain |
Multiple handlers, unknown which handles |
| Command |
Encapsulate request as object |
Need undo, queue, or log operations |
| Interpreter |
Define grammar and interpret sentences |
Have a simple language to parse |
| Iterator |
Sequential access without exposing internals |
Need to traverse collections |
| Mediator |
Centralize complex communications |
Many objects communicate in complex ways |
| Memento |
Capture and restore object state |
Need undo/snapshot functionality |
| Observer |
Notify dependents of state changes |
One-to-many dependency |
| State |
Alter behavior when state changes |
Object behavior depends on state |
| Strategy |
Encapsulate interchangeable algorithms |
Need to swap algorithms at runtime |
| Template Method |
Define skeleton, let subclasses fill in |
Algorithm structure fixed, steps vary |
| Visitor |
Add operations without changing classes |
Need to add many operations to stable structure |
Decision Guide
See Pattern Selection Guide for help choosing the right pattern.
How to Use This Reference
- Choosing a pattern: Start with the decision guide or tables above
- Learning a pattern: Read the full documentation with examples
- Quick reminder: Use the tables above for at-a-glance reference
- Implementation: Follow the pseudocode, adapt to your language
Language Translation Notes
The pseudocode in this reference uses these conventions:
class for type definitionsfunction for methods/functions-> for method calls on objects// for comments- Type hints shown as
name: Type
Translate to your language:
- PHP:
class, function, ->, //, type hints in docblocks or PHP 8+
- JavaScript/TypeScript:
class, function/arrow, ., //, TS types
- Python:
class, def, ., #, type hints
- Java/C#: Direct mapping with
new, generics
Based on concepts from "Design Patterns: Elements of Reusable Object-Oriented Software" by Gamma, Helm, Johnson, and Vlissides (Gang of Four), 1994.
Converted and distributed by TomeVault — claim your Tome and manage your conversions.
1---2name: gof-patterns3description: Gang of Four design patterns reference. Use this skill when implementing, discussing, or choosing object-oriented design patterns. Auto-activates for architecture decisions, refactoring, and decoupling concerns. Comprehensive coverage of all 23 GoF patterns with pseudocode examples. Use when this capability is needed.4---56# GoF Design Patterns Reference78A comprehensive reference for the Gang of Four design patterns. This skill provides language-agnostic guidance with pseudocode examples that can be translated to any programming language.910## When This Skill Activates1112This skill automatically activates when you:13- Ask about or need to implement a design pattern14- Need to choose between patterns for a design problem15- Are refactoring code and considering structural improvements16- Discuss architecture, decoupling, or extensibility17- Mention specific patterns: factory, singleton, observer, decorator, etc.1819## Quick Pattern Reference2021### Creational Patterns (Object Creation)22| Pattern | Intent | Use When |23|---------|--------|----------|24| [Abstract Factory](gof-creational/abstract-factory.md) | Create families of related objects | Need platform/theme independence |25| [Builder](gof-creational/builder.md) | Construct complex objects step-by-step | Object has many optional parts |26| [Factory Method](gof-creational/factory-method.md) | Let subclasses decide which class to instantiate | Don't know concrete types ahead of time |27| [Prototype](gof-creational/prototype.md) | Clone existing objects | Object creation is expensive |28| [Singleton](gof-creational/singleton.md) | Ensure single instance | Need exactly one shared instance |2930### Structural Patterns (Composition)31| Pattern | Intent | Use When |32|---------|--------|----------|33| [Adapter](gof-structural/adapter.md) | Convert interface to expected interface | Integrating incompatible interfaces |34| [Bridge](gof-structural/bridge.md) | Separate abstraction from implementation | Need to vary both independently |35| [Composite](gof-structural/composite.md) | Treat individual and groups uniformly | Have tree structures |36| [Decorator](gof-structural/decorator.md) | Add responsibilities dynamically | Need flexible extension |37| [Facade](gof-structural/facade.md) | Simplified interface to subsystem | Complex subsystem needs simple API |38| [Flyweight](gof-structural/flyweight.md) | Share common state efficiently | Many similar objects needed |39| [Proxy](gof-structural/proxy.md) | Control access to object | Need lazy loading, access control, logging |4041### Behavioral Patterns (Communication)42| Pattern | Intent | Use When |43|---------|--------|----------|44| [Chain of Responsibility](gof-behavioral/chain-of-responsibility.md) | Pass request along handler chain | Multiple handlers, unknown which handles |45| [Command](gof-behavioral/command.md) | Encapsulate request as object | Need undo, queue, or log operations |46| [Interpreter](gof-behavioral/interpreter.md) | Define grammar and interpret sentences | Have a simple language to parse |47| [Iterator](gof-behavioral/iterator.md) | Sequential access without exposing internals | Need to traverse collections |48| [Mediator](gof-behavioral/mediator.md) | Centralize complex communications | Many objects communicate in complex ways |49| [Memento](gof-behavioral/memento.md) | Capture and restore object state | Need undo/snapshot functionality |50| [Observer](gof-behavioral/observer.md) | Notify dependents of state changes | One-to-many dependency |51| [State](gof-behavioral/state.md) | Alter behavior when state changes | Object behavior depends on state |52| [Strategy](gof-behavioral/strategy.md) | Encapsulate interchangeable algorithms | Need to swap algorithms at runtime |53| [Template Method](gof-behavioral/template-method.md) | Define skeleton, let subclasses fill in | Algorithm structure fixed, steps vary |54| [Visitor](gof-behavioral/visitor.md) | Add operations without changing classes | Need to add many operations to stable structure |5556## Decision Guide5758See [Pattern Selection Guide](pattern-selection.md) for help choosing the right pattern.5960## How to Use This Reference61621. **Choosing a pattern**: Start with the decision guide or tables above632. **Learning a pattern**: Read the full documentation with examples643. **Quick reminder**: Use the tables above for at-a-glance reference654. **Implementation**: Follow the pseudocode, adapt to your language6667## Language Translation Notes6869The pseudocode in this reference uses these conventions:70- `class` for type definitions71- `function` for methods/functions72- `->` for method calls on objects73- `//` for comments74- Type hints shown as `name: Type`7576Translate to your language:77- **PHP**: `class`, `function`, `->`, `//`, type hints in docblocks or PHP 8+78- **JavaScript/TypeScript**: `class`, `function`/arrow, `.`, `//`, TS types79- **Python**: `class`, `def`, `.`, `#`, type hints80- **Java/C#**: Direct mapping with `new`, generics8182---8384*Based on concepts from "Design Patterns: Elements of Reusable Object-Oriented Software" by Gamma, Helm, Johnson, and Vlissides (Gang of Four), 1994.*8586---87> Converted and distributed by [TomeVault](https://tomevault.io/claim/grndlvl) — claim your Tome and manage your conversions.88<!-- tomevault:4.0:skill_md:2026-04-13 -->
tomevault-io