Add Classical Gang of Four Patterns documentation and multi-language examples

[Copilot]

Implements comprehensive documentation for four classical GoF patterns (Strategy, Factory, Observer, Decorator) with working examples across Python, Go, and TypeScript, demonstrating their relationship to SOLID principles.

Documentation

• Main: docs/11-application-development/11.2.4-classical-patterns.md
  • Organized by GoF categories (Creational/Behavioral/Structural)
  • Explicit SOLID cross-references to existing 11.2.1 content
  • Pattern recognition guidance for production codebases
  • Self-directed identification exercise

Code Examples

Strategy Pattern (Python) - Payment processing demonstrating Open/Closed Principle

class OrderProcessor:
    def __init__(self, payment_strategy: PaymentStrategy):
        self._payment_strategy = payment_strategy  # Closed for modification
    
# Add new payment methods without changing OrderProcessor
class BitcoinPayment(PaymentStrategy):  # Open for extension
    def process(self, order: Order) -> bool:
        # Implementation

Factory Pattern (Go) - Database abstraction demonstrating Dependency Inversion Principle

type UserService struct {
    db Database  // Depends on interface, not concrete MySQL/PostgreSQL
}

factory := GetDatabaseFactory("mysql")
db := factory.CreateDatabase(config)
service := NewUserService(db)  // Dependency injected

Observer Pattern (TypeScript) - Stock monitoring demonstrating loose coupling

class StockPrice {
    private observers: Observer[] = [];  // Depends on interface only
    
    setPrice(price: number) {
        this.notify();  // All observers notified automatically
    }
}

Decorator Pattern (Python) - Coffee customization avoiding class explosion

# No need for CoffeeWithMilk, CoffeeWithSugar, CoffeeWithMilkAndSugar...
coffee = Coffee()
coffee = MilkDecorator(coffee)  # Dynamic composition
coffee = SugarDecorator(coffee)

Quiz

Interactive quiz with 11 multi-language questions embedded in documentation:

• Pattern recognition from code snippets
• SOLID principle connections
• When to apply each pattern

Test Coverage

• Strategy (Python): 9 tests
• Factory (Go): 7 tests
• Observer (TypeScript): 19 tests
• Decorator (Python): 22 tests

All examples include READMEs with setup instructions, SOLID explanations, and cross-references to section 11.2.1.

Warning

Firewall rules blocked me from connecting to one or more addresses (expand for details)

I tried to connect to the following addresses, but was blocked by firewall rules:

• astral.sh
  • Triggering command: /usr/bin/curl curl -LsSf REDACTED (dns block)

If you need me to access, download, or install something from one of these locations, you can either:

• Configure Actions setup steps to set up my environment, which run before the firewall is enabled
• Add the appropriate URLs or hosts to the custom allowlist in this repository's Copilot coding agent settings (admins only)

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Task 3.0: Classical GoF Patterns Documentation and Examples (11.2.4)</issue_title>
<issue_description>## 🎯 Task Overview

Task ID: 3.0
Parent Spec: docs/specs/01-spec-design-patterns-section/01-spec-design-patterns-section.md
Depends On: Task 1.0, Task 2.0 (conceptually independent, but sequential for consistency)
Status: Ready for Implementation
Estimated Time: 2-3 hours

This task implements comprehensive documentation for Classical Gang of Four Patterns (11.2.4), including Strategy, Factory, Observer, and Decorator patterns with working examples distributed across languages, explicit SOLID connections, and an interactive quiz.

---

📋 Specification Context

Project Overview

This specification defines the remaining Design Patterns subsections for Chapter 11 (Application Development) of the DevOps Bootcamp. This task introduces selected Gang of Four patterns that directly relate to SOLID principles and are commonly used in production applications.

User Story

US-4: Recognizing Classical Patterns
As a senior CSCI student preparing for professional work, I want to recognize Strategy, Factory, Observer, and Decorator patterns in existing codebases so that I can understand and contribute to enterprise projects.

Functional Requirements

ID	Requirement
U4-FR1	The system shall explain Strategy Pattern with examples demonstrating swappable algorithms and explicit connection to Open/Closed Principle
U4-FR2	The system shall explain Factory Pattern with examples demonstrating object creation abstraction and explicit connection to Dependency Inversion Principle
U4-FR3	The system shall explain Observer Pattern with examples demonstrating event-driven communication between objects
U4-FR4	The system shall explain Decorator Pattern with examples demonstrating behavior extension and explicit connection to Open/Closed Principle
U4-FR5	The system shall organize pattern explanations by problem domain: Creational (Factory), Behavioral (Strategy, Observer), Structural (Decorator)
U4-FR6	The system shall explicitly connect each pattern to relevant SOLID principles with cross-references to 11.2.1 content
U4-FR7	The system shall provide pattern recognition exercises using real-world code snippets
U4-FR8	The system shall include a self-directed exercise for students to identify patterns in a production codebase of their choice
U4-FR9	The system shall include an interactive quiz testing pattern recognition across code snippets in multiple languages

---

✅ Acceptance Criteria (Proof Artifacts)

The following artifacts must exist and be verified for task completion:

• Documentation: docs/11-application-development/11.2.4-classical-patterns.md exists with complete content including front-matter, pattern explanations organized by category (Creational/Behavioral/Structural), SOLID connections, and exercises
• Strategy Pattern: examples/ch11/classical-patterns/strategy/ contains working implementation with README and explicit connection to Open/Closed Principle
• Factory Pattern: examples/ch11/classical-patterns/factory/ contains working implementation with README and explicit connection to Dependency Inversion Principle
• Observer Pattern: examples/ch11/classical-patterns/observer/ contains working implementation with README demonstrating event-driven communication
• Decorator Pattern: examples/ch11/classical-patterns/decorator/ contains working implementation with README and explicit connection to Open/Closed Principle
• Quiz: src/quizzes/chapter-11/11.2.4/classical-patterns-quiz.js exists with multi-language pattern recognition questions following quizdown format
• CLI Verification: Tests pass in all example directories (using appropriate test command per language)
• SOLID Integration: Each pattern README includes explicit cross-reference to relevant section in 11.2.1

---

📝 Sub-tasks

Documentation Tasks

• 3.1 Create documentation file docs/11-application-development/11.2.4-classical-patterns.md with front-matter (category: Application Development, technologies: Python/Go/TypeScript/Design Patterns, estReadingMinutes: 45, exercise definition)
• 3.2 Write introduction explaining Gang of Four patterns, their organization (Creational/Behavioral/Structural), and focus on patterns most relevant to SOLID principles
• 3.3 Write Strategy Pattern section (Behavioral) explaining swappable algorithms, explicit connection to Open/Closed Principle (extending behavior without modification), and cross-reference to 11.2.1
• 3.4 Write Factory Pattern section (Creational) explaining object creation abstraction, explicit connection to Dependency Inversion Principle (depending on abstractions), and cross-reference to...

• Fixes Task 3.0: Classical GoF Patterns Documentation and Examples (11.2.4) #823

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.