@booklib/skills 1.0.0 → 1.3.0

package/data-pipelines/examples/after.md

@@ -0,0 +1,97 @@
+# After
+
+A clean pipeline with separated extract/transform/load functions, idempotent upserts, retry logic, and proper error handling.
+
+```python
+import logging
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from functools import wraps
+
+import psycopg2
+import requests
+from requests.exceptions import RequestException
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SaleRecord:
+    id: str
+    sale_date: datetime
+    revenue: float
+    region: str
+
+
+def with_retry(max_attempts: int = 3, backoff_seconds: float = 2.0):
+    """Decorator: retry a function on transient failures with exponential backoff."""
+    def decorator(fn):
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return fn(*args, **kwargs)
+                except (RequestException, psycopg2.OperationalError) as exc:
+                    if attempt == max_attempts:
+                        raise
+                    wait = backoff_seconds ** attempt
+                    logger.warning("Attempt %d/%d failed: %s — retrying in %.1fs",
+                                   attempt, max_attempts, exc, wait)
+                    time.sleep(wait)
+        return wrapper
+    return decorator
+
+
+@with_retry(max_attempts=3)
+def extract(api_url: str) -> list[dict]:
+    """Fetch raw sales records from the partner API."""
+    response = requests.get(api_url, timeout=30)
+    response.raise_for_status()
+    return response.json()["sales"]
+
+
+def transform(raw_records: list[dict]) -> list[SaleRecord]:
+    """Parse and normalise raw API records into typed SaleRecord objects."""
+    return [
+        SaleRecord(
+            id=rec["id"],
+            sale_date=datetime.fromisoformat(rec["date"]),
+            revenue=float(rec["amount_usd"]),
+            region=rec["region"].strip().upper(),
+        )
+        for rec in raw_records
+    ]
+
+
+def load(records: list[SaleRecord], dsn: str) -> int:
+    """Upsert records into fact_sales. Idempotent: re-running is safe."""
+    upsert_sql = """
+        INSERT INTO fact_sales (sale_id, sale_date, revenue, region, loaded_at)
+        VALUES (%(id)s, %(sale_date)s, %(revenue)s, %(region)s, NOW())
+        ON CONFLICT (sale_id) DO UPDATE
+            SET revenue   = EXCLUDED.revenue,
+                loaded_at = EXCLUDED.loaded_at
+    """
+    with psycopg2.connect(dsn) as conn, conn.cursor() as cur:
+        cur.executemany(upsert_sql, [vars(r) for r in records])
+        loaded = cur.rowcount
+    logger.info("Upserted %d records into fact_sales", loaded)
+    return loaded
+
+
+def run_pipeline(api_url: str, warehouse_dsn: str) -> None:
+    logger.info("Starting sales pipeline")
+    raw = extract(api_url)
+    records = transform(raw)
+    loaded = load(records, warehouse_dsn)
+    logger.info("Pipeline complete: %d records loaded", loaded)
+```
+
+Key improvements:
+- Extract, transform, and load are separate functions with single responsibilities — each is independently testable and replaceable (Ch 13: Best Practices — separation of concerns)
+- `ON CONFLICT (sale_id) DO UPDATE` makes the load idempotent — re-running the pipeline never creates duplicate rows (Ch 13: Idempotency)
+- `@with_retry` decorator handles transient API and database failures with exponential backoff (Ch 6: API Ingestion — retry logic)
+- `SaleRecord` dataclass replaces a raw dict, providing type safety and named field access in the transform step
+- `psycopg2.connect` used as a context manager ensures the connection and transaction are always closed and committed correctly (Ch 4: Database Ingestion)
+- Structured logging with `logger.info/warning` replaces bare `print` — output is filterable and includes context (Ch 12: Monitoring)

package/data-pipelines/examples/before.md

@@ -0,0 +1,37 @@
+# Before
+
+A Python ETL script that mixes extraction, transformation, and loading in one function with no error handling, no idempotency, and no retry logic.
+
+```python
+import psycopg2
+import requests
+from datetime import datetime
+
+def run_pipeline():
+    # Extract: fetch from API
+    resp = requests.get("https://api.partner.com/sales/export")
+    data = resp.json()
+
+    # Connect to warehouse
+    conn = psycopg2.connect("host=dw user=etl dbname=warehouse")
+    cur = conn.cursor()
+
+    # Transform + Load: all in one loop, no error handling
+    for record in data["sales"]:
+        sale_date = datetime.strptime(record["date"], "%Y-%m-%dT%H:%M:%S")
+        revenue = float(record["amount_usd"])
+        region = record["region"].strip().upper()
+
+        # No upsert — re-running inserts duplicates
+        cur.execute("""
+            INSERT INTO fact_sales (sale_id, sale_date, revenue, region, loaded_at)
+            VALUES (%s, %s, %s, %s, NOW())
+        """, (record["id"], sale_date, revenue, region))
+
+    conn.commit()
+    cur.close()
+    conn.close()
+    print("done")
+
+run_pipeline()
+```

package/data-pipelines/scripts/new_pipeline.py

@@ -0,0 +1,444 @@
+#!/usr/bin/env python3
+"""
+new_pipeline.py — Scaffold a new data pipeline with extract/transform/load structure.
+Usage: python new_pipeline.py <pipeline-name> [--source csv|api|db] [--target db|file|api]
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+from string import Template
+
+# ---------------------------------------------------------------------------
+# File templates
+# ---------------------------------------------------------------------------
+
+EXTRACT_CSV = '''\
+"""extract.py — Extract data from a CSV source."""
+
+import csv
+import logging
+import time
+from pathlib import Path
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+
+def retry(max_attempts=3, delay=2.0, exceptions=(Exception,)):
+    """Retry decorator with exponential backoff."""
+    def decorator(fn):
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return fn(*args, **kwargs)
+                except exceptions as exc:
+                    if attempt == max_attempts:
+                        raise
+                    wait = delay * (2 ** (attempt - 1))
+                    logger.warning("Attempt %d failed: %s. Retrying in %.1fs...", attempt, exc, wait)
+                    time.sleep(wait)
+        return wrapper
+    return decorator
+
+
+@retry(max_attempts=3, exceptions=(OSError,))
+def extract(source_path: str) -> list[dict]:
+    """Read rows from a CSV file. Returns a list of dicts."""
+    path = Path(source_path)
+    if not path.exists():
+        raise FileNotFoundError(f"Source file not found: {path}")
+    logger.info("Extracting from %s", path)
+    with path.open(newline="", encoding="utf-8") as fh:
+        reader = csv.DictReader(fh)
+        rows = list(reader)
+    logger.info("Extracted %d rows", len(rows))
+    return rows
+'''
+
+EXTRACT_API = '''\
+"""extract.py — Extract data from an HTTP API source."""
+
+import json
+import logging
+import time
+import urllib.error
+import urllib.request
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+BASE_URL = "https://api.example.com/data"
+API_KEY = ""  # Set via environment variable in production
+
+
+def retry(max_attempts=3, delay=2.0, exceptions=(Exception,)):
+    """Retry decorator with exponential backoff."""
+    def decorator(fn):
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return fn(*args, **kwargs)
+                except exceptions as exc:
+                    if attempt == max_attempts:
+                        raise
+                    wait = delay * (2 ** (attempt - 1))
+                    logger.warning("Attempt %d failed: %s. Retrying in %.1fs...", attempt, exc, wait)
+                    time.sleep(wait)
+        return wrapper
+    return decorator
+
+
+@retry(max_attempts=3, exceptions=(urllib.error.URLError, OSError))
+def extract(endpoint: str = BASE_URL) -> list[dict]:
+    """Fetch JSON records from an API endpoint. Returns a list of dicts."""
+    logger.info("Extracting from %s", endpoint)
+    req = urllib.request.Request(endpoint, headers={"Accept": "application/json"})
+    with urllib.request.urlopen(req, timeout=30) as response:
+        data = json.loads(response.read())
+    records = data if isinstance(data, list) else data.get("results", data.get("items", []))
+    logger.info("Extracted %d records", len(records))
+    return records
+'''
+
+EXTRACT_DB = '''\
+"""extract.py — Extract data from a database source."""
+
+import logging
+import sqlite3
+import time
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+DB_PATH = "source.db"
+QUERY = "SELECT * FROM source_table"
+
+
+def retry(max_attempts=3, delay=2.0, exceptions=(Exception,)):
+    """Retry decorator with exponential backoff."""
+    def decorator(fn):
+        @wraps(fn)
+        def wrapper(*args, **kwargs):
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return fn(*args, **kwargs)
+                except exceptions as exc:
+                    if attempt == max_attempts:
+                        raise
+                    wait = delay * (2 ** (attempt - 1))
+                    logger.warning("Attempt %d failed: %s. Retrying in %.1fs...", attempt, exc, wait)
+                    time.sleep(wait)
+        return wrapper
+    return decorator
+
+
+@retry(max_attempts=3, exceptions=(sqlite3.OperationalError,))
+def extract(db_path: str = DB_PATH, query: str = QUERY) -> list[dict]:
+    """Query records from a SQLite database. Returns a list of dicts."""
+    logger.info("Connecting to %s", db_path)
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    try:
+        cursor = conn.execute(query)
+        rows = [dict(row) for row in cursor.fetchall()]
+    finally:
+        conn.close()
+    logger.info("Extracted %d rows", len(rows))
+    return rows
+'''
+
+TRANSFORM_TEMPLATE = '''\
+"""transform.py — Transform extracted records."""
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _clean_record(record: dict[str, Any]) -> dict[str, Any]:
+    """Strip whitespace from string values and drop empty fields."""
+    cleaned = {}
+    for key, value in record.items():
+        if isinstance(value, str):
+            value = value.strip()
+        if value not in (None, "", []):
+            cleaned[key] = value
+    return cleaned
+
+
+def _validate_record(record: dict[str, Any]) -> bool:
+    """Return True if the record is valid. Customize required fields here."""
+    # TODO: add field-specific validation
+    return bool(record)
+
+
+def transform(records: list[dict]) -> list[dict]:
+    """Clean, validate, and reshape records for loading."""
+    logger.info("Transforming %d records", len(records))
+    output = []
+    skipped = 0
+    for record in records:
+        cleaned = _clean_record(record)
+        if not _validate_record(cleaned):
+            skipped += 1
+            continue
+        # TODO: add field mappings / enrichment here
+        output.append(cleaned)
+    if skipped:
+        logger.warning("Skipped %d invalid records", skipped)
+    logger.info("Transformed %d records", len(output))
+    return output
+'''
+
+LOAD_DB = '''\
+"""load.py — Idempotent load into a SQLite database using upsert."""
+
+import logging
+import sqlite3
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+DB_PATH = "output.db"
+TABLE = "$pipeline_name"
+# Define a unique key column used for upsert conflict detection
+UNIQUE_KEY = "id"
+
+
+def _ensure_table(conn: sqlite3.Connection, sample: dict[str, Any]) -> None:
+    columns = ", ".join(
+        f"{col} TEXT" if col != UNIQUE_KEY else f"{col} TEXT PRIMARY KEY"
+        for col in sample
+    )
+    conn.execute(f"CREATE TABLE IF NOT EXISTS {TABLE} ({columns})")
+    conn.commit()
+
+
+def load(records: list[dict]) -> int:
+    """Upsert records into SQLite. Returns number of rows written."""
+    if not records:
+        logger.info("No records to load.")
+        return 0
+    logger.info("Loading %d records into %s:%s", len(records), DB_PATH, TABLE)
+    conn = sqlite3.connect(DB_PATH)
+    try:
+        _ensure_table(conn, records[0])
+        cols = ", ".join(records[0].keys())
+        placeholders = ", ".join("?" for _ in records[0])
+        sql = (
+            f"INSERT OR REPLACE INTO {TABLE} ({cols}) VALUES ({placeholders})"
+        )
+        conn.executemany(sql, [list(r.values()) for r in records])
+        conn.commit()
+    finally:
+        conn.close()
+    logger.info("Loaded %d records", len(records))
+    return len(records)
+'''
+
+LOAD_FILE = '''\
+"""load.py — Write records to a CSV or JSON file (idempotent by overwrite)."""
+
+import csv
+import json
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+OUTPUT_PATH = "$pipeline_name_output.csv"
+
+
+def load(records: list[dict], output_path: str = OUTPUT_PATH) -> int:
+    """Write records to a file. Overwrites to ensure idempotency."""
+    if not records:
+        logger.info("No records to load.")
+        return 0
+    path = Path(output_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.suffix == ".json":
+        path.write_text(json.dumps(records, indent=2, default=str), encoding="utf-8")
+    else:
+        with path.open("w", newline="", encoding="utf-8") as fh:
+            writer = csv.DictWriter(fh, fieldnames=records[0].keys())
+            writer.writeheader()
+            writer.writerows(records)
+    logger.info("Wrote %d records to %s", len(records), path)
+    return len(records)
+'''
+
+LOAD_API = '''\
+"""load.py — POST records to an API endpoint (idempotent with dedup key)."""
+
+import json
+import logging
+import urllib.error
+import urllib.request
+
+logger = logging.getLogger(__name__)
+
+TARGET_URL = "https://api.example.com/ingest"
+BATCH_SIZE = 100
+
+
+def _post_batch(batch: list[dict]) -> None:
+    payload = json.dumps(batch).encode("utf-8")
+    req = urllib.request.Request(
+        TARGET_URL,
+        data=payload,
+        method="POST",
+        headers={"Content-Type": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            status = resp.status
+            logger.info("Batch of %d posted — HTTP %d", len(batch), status)
+    except urllib.error.HTTPError as exc:
+        logger.error("HTTP error %d posting batch: %s", exc.code, exc.reason)
+        raise
+
+
+def load(records: list[dict]) -> int:
+    """POST records in batches. Returns total records sent."""
+    if not records:
+        logger.info("No records to load.")
+        return 0
+    total = 0
+    for i in range(0, len(records), BATCH_SIZE):
+        batch = records[i:i + BATCH_SIZE]
+        _post_batch(batch)
+        total += len(batch)
+    logger.info("Loaded %d records via API", total)
+    return total
+'''
+
+PIPELINE_TEMPLATE = '''\
+"""pipeline.py — Orchestrator: extract → transform → load."""
+
+import logging
+import sys
+import time
+
+from extract import extract
+from transform import transform
+from load import load
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(name)s  %(message)s",
+    datefmt="%Y-%m-%dT%H:%M:%S",
+)
+logger = logging.getLogger("$pipeline_name")
+
+
+def run() -> int:
+    """Run the full pipeline. Returns exit code (0=success, 1=failure)."""
+    start = time.monotonic()
+    logger.info("Pipeline '$pipeline_name' starting")
+    try:
+        raw = extract()
+        records = transform(raw)
+        count = load(records)
+        elapsed = time.monotonic() - start
+        logger.info(
+            "Pipeline complete — %d records loaded in %.2fs", count, elapsed
+        )
+        return 0
+    except Exception as exc:
+        logger.exception("Pipeline failed: %s", exc)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(run())
+'''
+
+REQUIREMENTS_TEMPLATE = '''\
+# Runtime dependencies for $pipeline_name pipeline
+# Add your project-specific packages below.
+
+# Uncomment as needed:
+# requests>=2.31          # for API sources/targets
+# psycopg2-binary>=2.9    # for PostgreSQL
+# pymysql>=1.1            # for MySQL
+# pandas>=2.0             # for complex transformations
+# pydantic>=2.0           # for record validation
+'''
+
+# ---------------------------------------------------------------------------
+# Source/target template selection
+# ---------------------------------------------------------------------------
+
+EXTRACT_TEMPLATES = {"csv": EXTRACT_CSV, "api": EXTRACT_API, "db": EXTRACT_DB}
+LOAD_TEMPLATES = {"db": LOAD_DB, "file": LOAD_FILE, "api": LOAD_API}
+
+
+def render(template_str: str, pipeline_name: str) -> str:
+    safe_name = pipeline_name.replace("-", "_")
+    return Template(template_str).safe_substitute(pipeline_name=safe_name)
+
+
+def create_pipeline(name: str, source: str, target: str) -> None:
+    base = Path(name)
+    if base.exists():
+        print(f"Error: directory '{base}' already exists. Choose a different name.")
+        sys.exit(1)
+    base.mkdir(parents=True)
+
+    files = {
+        "extract.py": render(EXTRACT_TEMPLATES[source], name),
+        "transform.py": render(TRANSFORM_TEMPLATE, name),
+        "load.py": render(LOAD_TEMPLATES[target], name),
+        "pipeline.py": render(PIPELINE_TEMPLATE, name),
+        "requirements.txt": render(REQUIREMENTS_TEMPLATE, name),
+    }
+
+    created = []
+    for filename, content in files.items():
+        path = base / filename
+        path.write_text(content, encoding="utf-8")
+        created.append(str(path))
+
+    print(f"\nPipeline '{name}' created successfully!\n")
+    print(f"  Source  : {source}")
+    print(f"  Target  : {target}")
+    print(f"\nFiles created:")
+    for f in created:
+        print(f"  {f}")
+    print(f"\nNext steps:")
+    print(f"  1. cd {name}")
+    print(f"  2. Review extract.py and update source configuration")
+    print(f"  3. Customize transform.py with your business logic")
+    print(f"  4. Review load.py and configure target destination")
+    print(f"  5. pip install -r requirements.txt   # add packages as needed")
+    print(f"  6. python pipeline.py")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Scaffold a new data pipeline (extract → transform → load)"
+    )
+    parser.add_argument("name", help="Pipeline name (used as directory name)")
+    parser.add_argument(
+        "--source",
+        choices=["csv", "api", "db"],
+        default="csv",
+        help="Data source type (default: csv)",
+    )
+    parser.add_argument(
+        "--target",
+        choices=["db", "file", "api"],
+        default="db",
+        help="Data target type (default: db)",
+    )
+    args = parser.parse_args()
+    create_pipeline(args.name, args.source, args.target)
+
+
+if __name__ == "__main__":
+    main()

package/design-patterns/evals/evals.json

@@ -0,0 +1,46 @@
+{
+  "evals": [
+    {
+      "id": "eval-01-strategy-pattern-if-else",
+      "prompt": "Review this Java code:\n\n```java\npublic class PaymentProcessor {\n    public void processPayment(String paymentType, double amount) {\n        if (paymentType.equals(\"CREDIT_CARD\")) {\n            System.out.println(\"Validating credit card...\");\n            System.out.println(\"Charging $\" + amount + \" to credit card\");\n            System.out.println(\"Sending credit card receipt\");\n        } else if (paymentType.equals(\"PAYPAL\")) {\n            System.out.println(\"Redirecting to PayPal...\");\n            System.out.println(\"Confirming PayPal payment of $\" + amount);\n            System.out.println(\"Sending PayPal confirmation email\");\n        } else if (paymentType.equals(\"CRYPTO\")) {\n            System.out.println(\"Opening crypto wallet...\");\n            System.out.println(\"Broadcasting transaction of $\" + amount);\n            System.out.println(\"Waiting for blockchain confirmation\");\n        } else if (paymentType.equals(\"BANK_TRANSFER\")) {\n            System.out.println(\"Initiating bank transfer...\");\n            System.out.println(\"Transferring $\" + amount + \" via ACH\");\n            System.out.println(\"Sending bank transfer confirmation\");\n        } else {\n            throw new IllegalArgumentException(\"Unknown payment type: \" + paymentType);\n        }\n    }\n    \n    public double calculateFee(String paymentType, double amount) {\n        if (paymentType.equals(\"CREDIT_CARD\")) {\n            return amount * 0.029 + 0.30;\n        } else if (paymentType.equals(\"PAYPAL\")) {\n            return amount * 0.034 + 0.30;\n        } else if (paymentType.equals(\"CRYPTO\")) {\n            return amount * 0.01;\n        } else if (paymentType.equals(\"BANK_TRANSFER\")) {\n            return 0.25;\n        } else {\n            throw new IllegalArgumentException(\"Unknown payment type: \" + paymentType);\n        }\n    }\n}\n```",
+      "expectations": [
+        "Identifies this as a prime Strategy pattern candidate — the payment algorithm varies by type",
+        "Calls out the Open-Closed Principle violation: adding a new payment method requires modifying this class",
+        "Notes that the parallel if/else chains in processPayment and calculateFee are a code smell (duplicated conditional logic)",
+        "Recommends extracting a PaymentStrategy interface with processPayment(double amount) and calculateFee(double amount) methods",
+        "Suggests concrete strategy classes: CreditCardStrategy, PayPalStrategy, CryptoStrategy, BankTransferStrategy",
+        "Describes the Context class (PaymentProcessor) holding a reference to the strategy interface",
+        "Notes that using a String 'paymentType' is fragile — a Map<String, PaymentStrategy> or enum-based lookup is safer",
+        "Provides a sketch of the refactored interface and at least one concrete implementation",
+        "References the principle: 'Encapsulate what varies' — payment behavior is what varies here"
+      ]
+    },
+    {
+      "id": "eval-02-unnecessary-singleton",
+      "prompt": "Review this Java code:\n\n```java\npublic class TaxCalculator {\n    private static TaxCalculator instance;\n    private double vatRate = 0.20;\n    private double salesTaxRate = 0.08;\n    \n    private TaxCalculator() {}\n    \n    public static TaxCalculator getInstance() {\n        if (instance == null) {\n            instance = new TaxCalculator();\n        }\n        return instance;\n    }\n    \n    public double calculateVAT(double price) {\n        return price * vatRate;\n    }\n    \n    public double calculateSalesTax(double price) {\n        return price * salesTaxRate;\n    }\n    \n    public void setVatRate(double vatRate) {\n        this.vatRate = vatRate;\n    }\n    \n    public void setSalesTaxRate(double salesTaxRate) {\n        this.salesTaxRate = salesTaxRate;\n    }\n}\n\n// Usage in application code:\nTaxCalculator calc = TaxCalculator.getInstance();\ncalc.setVatRate(0.23);  // Portuguese VAT\nOrderTotal total = calc.calculateVAT(orderAmount);\n```",
+      "expectations": [
+        "Identifies the Singleton pattern and flags it as misapplied here",
+        "Explains why global mutable state is dangerous: setVatRate() and setSalesTaxRate() make this Singleton a shared mutable object — one caller's rate change affects all other callers",
+        "Notes the race condition: getInstance() is not thread-safe (no synchronization, no double-checked locking, no holder idiom)",
+        "Points out that a stateless or value-parameterized object has no reason to be a Singleton — TaxCalculator is just computation",
+        "Recommends removing the Singleton and using simple instantiation or dependency injection",
+        "Suggests making TaxCalculator immutable: accept rates in the constructor, remove setters",
+        "May suggest using the Strategy pattern if tax rules vary by jurisdiction",
+        "References the anti-pattern: 'Singleton abuse — using Singleton as a global variable container rather than for genuine single-instance needs'"
+      ]
+    },
+    {
+      "id": "eval-03-observer-pattern-correct",
+      "prompt": "Review this Java code:\n\n```java\npublic interface StockObserver {\n    void update(String ticker, double price, double changePercent);\n}\n\npublic class StockMarket {\n    private final Map<String, List<StockObserver>> observers = new HashMap<>();\n    private final Map<String, Double> prices = new HashMap<>();\n    \n    public void registerObserver(String ticker, StockObserver observer) {\n        observers.computeIfAbsent(ticker, k -> new ArrayList<>()).add(observer);\n    }\n    \n    public void removeObserver(String ticker, StockObserver observer) {\n        List<StockObserver> tickerObservers = observers.get(ticker);\n        if (tickerObservers != null) {\n            tickerObservers.remove(observer);\n        }\n    }\n    \n    public void updatePrice(String ticker, double newPrice) {\n        double oldPrice = prices.getOrDefault(ticker, newPrice);\n        prices.put(ticker, newPrice);\n        double changePercent = oldPrice != 0 ? ((newPrice - oldPrice) / oldPrice) * 100 : 0;\n        notifyObservers(ticker, newPrice, changePercent);\n    }\n    \n    private void notifyObservers(String ticker, double price, double changePercent) {\n        List<StockObserver> tickerObservers = observers.getOrDefault(ticker, Collections.emptyList());\n        for (StockObserver observer : new ArrayList<>(tickerObservers)) {\n            observer.update(ticker, price, changePercent);\n        }\n    }\n}\n\npublic class PriceAlertService implements StockObserver {\n    private final double threshold;\n    \n    public PriceAlertService(double threshold) {\n        this.threshold = threshold;\n    }\n    \n    @Override\n    public void update(String ticker, double price, double changePercent) {\n        if (Math.abs(changePercent) >= threshold) {\n            System.out.println(\"ALERT: \" + ticker + \" moved \" + changePercent + \"% to $\" + price);\n        }\n    }\n}\n```",
+      "expectations": [
+        "Recognizes this as a correctly implemented Observer pattern and says so explicitly",
+        "Praises the use of a StockObserver interface (programming to an interface, not an implementation)",
+        "Praises the removeObserver method — the SKILL.md specifically flags 'Observer memory leaks — registered observers never unregistered' as an anti-pattern to catch",
+        "Praises the defensive copy 'new ArrayList<>(tickerObservers)' in notifyObservers, which prevents ConcurrentModificationException if an observer deregisters during notification",
+        "Praises per-ticker observer registration — observers only receive events for the tickers they care about",
+        "Does NOT manufacture fake issues just to have something to say",
+        "May offer optional improvements (e.g., thread safety with CopyOnWriteArrayList, using java.util.EventListener, or noting that prices map isn't thread-safe) but clearly frames these as non-critical suggestions"
+      ]
+    }
+  ]
+}

package/design-patterns/examples/after.md

@@ -0,0 +1,52 @@
+# After
+
+Each payment method is extracted into its own `PaymentStrategy` implementation behind a common interface, making it trivial to add new methods without touching existing code.
+
+```kotlin
+// Strategy interface — the contract every payment method must fulfill
+interface PaymentStrategy {
+    fun process(order: Order): PaymentResult
+}
+
+// One class per payment method — focused, testable, replaceable
+class CreditCardPaymentStrategy : PaymentStrategy {
+    override fun process(order: Order): PaymentResult {
+        val token = CreditCardGateway.tokenize(order.cardNumber)
+        val charge = CreditCardGateway.charge(token, order.totalAmount)
+        return PaymentResult(success = charge.success, transactionId = charge.id,
+                             errorMessage = charge.error.takeIf { !charge.success })
+    }
+}
+
+class PayPalPaymentStrategy : PaymentStrategy {
+    override fun process(order: Order): PaymentResult {
+        val session = PayPalClient.createSession(order.paypalEmail)
+        val payment = PayPalClient.executePayment(session, order.totalAmount)
+        return PaymentResult(success = payment.approved, transactionId = payment.token)
+    }
+}
+
+class BankTransferPaymentStrategy : PaymentStrategy {
+    override fun process(order: Order): PaymentResult {
+        val ref = BankTransferService.initiate(order.iban, order.totalAmount)
+        return PaymentResult(success = ref != null, transactionId = ref,
+                             errorMessage = "Bank transfer initiation failed".takeIf { ref == null })
+    }
+}
+
+// Context: delegates entirely to the injected strategy
+class PaymentProcessor(private val strategy: PaymentStrategy) {
+    fun process(order: Order): PaymentResult = strategy.process(order)
+}
+
+// Usage — caller selects strategy; PaymentProcessor is unaware of the type
+val processor = PaymentProcessor(CreditCardPaymentStrategy())
+val result = processor.process(order)
+```
+
+Key improvements:
+- If/else chain replaced with Strategy pattern — adding a new payment method requires a new class only, no changes to `PaymentProcessor` (Open-Closed Principle)
+- Each strategy is independently testable with a mock `Order`
+- `PaymentProcessor` depends on the `PaymentStrategy` abstraction, not concrete gateway classes (Dependency Inversion Principle)
+- Responsibility for "how to pay" is encapsulated inside each strategy class (Encapsulate What Varies)
+- Caller selects strategy through constructor injection, enabling runtime switching and easy testing