Reference and Selective Reading

You do not need to read the source books front-to-back for this module. Use the concept pages and practice pages first. Open these local chunks only when you need alternate exposition, a precise definition, or more worked examples.

Source Roles

Source	Role	Why it is here
Head First Design Patterns	Primary narrative teacher	Best at explaining why a pattern exists and what force it absorbs
Design Patterns (GoF)	Canonical reference	Best for precise definitions, participants, applicability, and sample code
Refactoring (Fowler)	Selective support	Best for the mechanics of moving toward (or away from) a pattern safely
Clean Code (Martin)	Selective support	Best short chapter on systems and dependency injection
Good Code, Bad Code (Tom Long)	Judgment support	Best modern restatement of "composition over inheritance" and DI
OOAD	Background only	Alternate angle on inheritance design; rarely needed here

Read Only If Stuck

Creational -- Construction Flexibility

• Head First: The Factory Pattern (intro)
• Head First: Identifying the Aspects That Vary
• Head First: The Simple Factory Defined
• Head First: A Framework for the Pizza Store
• Head First: Factory Method Pattern Defined
• Head First: Looking at Object Dependencies
• Head First: Applying the Principle
• Head First: Families of Ingredients
• Head First: Revisiting Our Pizza Stores
• Head First: Abstract Factory Pattern Defined
• Head First: The Singleton Pattern
• Head First: Dissecting the Classic Singleton Pattern
• GoF: Factories and Product Classes
• GoF: Abstract Factory -- Intent
• GoF: Abstract Factory -- Implementation
• GoF: Abstract Factory -- Sample Code
• GoF: Builder -- Applicability
• GoF: Builder -- Sample Code
• GoF: Factory Method -- Applicability
• GoF: Factory Method -- Implementation
• GoF: Factory Method -- Related Patterns
• GoF: Prototype -- Applicability
• GoF: Prototype -- Sample Code
• GoF: Singleton -- Implementation
• GoF: Singleton -- Sample Code
• GoF: Singleton -- Related Patterns
• Good Code, Bad Code: The Builder Pattern
• Refactoring: Replace Constructor with Factory Function

Structural -- Interface Bridging

• GoF: 4. Structural Patterns (intro)
• GoF: Adapter -- Applicability
• GoF: Adapter -- Sample Code
• GoF: Bridge -- Intent
• GoF: Bridge -- Participants
• GoF: Bridge -- Sample Code
• GoF: Bridge -- Known Uses
• GoF: Facade -- Participants
• GoF: Facade -- Known Uses
• Head First: The Adapter and Facade Patterns (chapter)
• Head First: How the Client Uses the Adapter
• Head First: Object and Class Adapters
• Head First: Enumeration-Iterator Adapter
• Head First: Lights, Camera, Facade
• Head First: Facade Pattern Defined

Structural -- Composition and Layering

• Head First: The Open/Closed Principle
• Head First: Meet the Decorator Pattern
• Head First: New Barista Training
• Head First: Coding Condiments
• Head First: Real-World Decorators -- Java I/O
• Head First: The Composite Pattern Defined
• Head First: Designing Menus with Composite
• Head First: The Proxy Pattern -- Controlling Object Access
• Head First: The Role of the Remote Proxy
• Head First: Get Ready for the Virtual Proxy
• Head First: Designing the Album Cover Virtual Proxy
• Head First: Using Java Proxy to Create a Protection Proxy
• GoF: Composite -- Implementation
• GoF: Composite -- Sample Code
• GoF: Composite -- Known Uses
• GoF: Decorator -- Implementation
• GoF: Decorator -- Sample Code
• GoF: Proxy -- Implementation
• GoF: Proxy -- Sample Code

Pragmatic Pattern Selection

• GoF: 1.5 Organizing the Catalog
• GoF: Class Versus Interface Inheritance
• GoF: Putting Reuse Mechanisms to Work
• GoF: Delegation
• GoF: Designing for Change (Part 1)
• GoF: Designing for Change (Part 2)
• GoF: 1.7 How to Select a Design Pattern
• Head First: Better Living with Patterns
• Head First: May the Force Be with You (Part 1)
• Head First: May the Force Be with You (Part 2)
• Head First: Organizing Design Patterns
• Head First: Thinking in Patterns
• Head First: Cruisin' Objectville with the Gang of Four
• Head First: The Patterns Zoo
• Good Code, Bad Code: Class Inheritance Can Be Problematic
• Good Code, Bad Code: Solution -- Use Composition

Dependency Injection and Composition Roots

• Clean Code: Chapter 11 -- Systems / Dependency Injection
• Good Code, Bad Code: Design with Dependency Injection in Mind

Optional Deep Dive

• GoF: 1.5 Organizing the Catalog -- the categorization that underlies the module
• GoF: Determining Object Granularity -- for "should this be one class or several"
• GoF: Encapsulating Implementation Dependencies -- a second angle on Bridge
• Head First: Safety Versus Transparency -- short but sharp on Composite trade-offs
• External: Mark Seemann, Composition Root
• External: Mark Seemann, DI-Friendly Framework
• External: Martin Fowler, Inversion of Control Containers and the Dependency Injection pattern
• External: Steve Yegge, Execution in the Kingdom of Nouns
• External: refactoring.guru, Creational Patterns and Structural Patterns

Concept-to-Source Map

Primary concept	Best source if stuck	Why this source
Factory Method	GoF: Factory Method -- Applicability	Canonical applicability list
Abstract Factory	GoF: Abstract Factory -- Intent	Canonical intent and family-of-products argument
Builder	Good Code, Bad Code: The Builder Pattern	Strongest modern fluent-Builder treatment
Prototype / Singleton	Head First: Dissecting the Classic Singleton	Best warning-first treatment
Adapter	Head First: The Adapter and Facade Patterns	Best intent-first explanation
Facade	Head First: Lights, Camera, Facade	Clearest real-world example
Bridge	GoF: Bridge -- Intent	Only thorough local source
Composite	Head First: The Composite Pattern Defined	Best safety-vs-transparency discussion
Decorator	Head First: Meet the Decorator Pattern	Best narrative with Java I/O anchor
Proxy	Head First: The Proxy Pattern	Covers all three major kinds with one story
Pattern categories and selection	GoF: 1.7 How to Select a Design Pattern	Canonical checklist
Pattern misuse and cargo-culting	Head First: May the Force Be with You (Part 1)	Most direct treatment of force-based judgment
Simpler alternatives	Good Code, Bad Code: Use Composition	Modern argument for composition and small units
Dependency injection	Clean Code: Chapter 11 -- Systems	Shortest clearest DI primer
Composition roots	External: Mark Seemann, Composition Root	Canonical short definition of the pattern