Reference document · where the material comes from

Resources

Every lesson in this course points at a primary source rather than paraphrasing one. This is the full list, with what each is good for. Books are cited by chapter inside the lessons themselves.

Knowledge

The course model

• Software Design Mastery (ArjanCodes)
  The curriculum this course is modeled on: Core Designer → System Designer → Master Designer. Use for: phase/module structure, lesson-level topic framing, and the "design by balancing forces" framing.
• The Software Designer Mindset (ArjanCodes course)
  Arjan's "7 Principles of Modern Software Design" (composition over inheritance, high cohesion, low coupling, start with the data, depend on abstractions, separate creation from use, keep things simple). Use for: principle-level lessons (0002, 0007, 0015–0017).
• Software Design Guide (ArjanCodes, free PDF)
  Seven-step design document workflow. Use for: lessons on structuring for stability and module organization.
• sdm — code examples for Software Design Mastery (GitHub)
  Official example code for the mastery program. Use for: realistic (non-toy) worked examples across all phases.
• ArjanCodes YouTube channel
  Primary video source; topics include coupling, cohesion, the Law of Demeter, strategy pattern, ports & adapters, error handling. Use for: the "watch first" recommendation in most lessons.

Books (opinionated, referenced by chapter in lessons)

• A Philosophy of Software Design, John Ousterhout — complexity, deep modules, information hiding, "define errors out of existence", design it twice, designing for performance.
• Clean Architecture, Robert C. Martin — SRP as "reason to change", OCP, DIP, component cohesion (REP/CCP/CRP), boundaries.
• The Pragmatic Programmer, Hunt & Thomas — DRY, Law of Demeter, "tell, don't ask", no global mutable state, rule of three.
• Code Complete, Steve McConnell — the deepest treatment of coupling and cohesion (ch. 5–6).
• Refactoring, Martin Fowler — catalog of code smells and their fixes.
• Working Effectively with Legacy Code, Michael Feathers — seams, characterization tests, changing software safely.
• Design Patterns, Gamma et al. (GoF) — canonical pattern catalog; Strategy (behavioral), Adapter & Facade (structural).
• Head First Design Patterns, Freeman et al. — the most accessible pattern walkthroughs; Strategy, Adapter, Facade.
• Domain-Driven Design, Eric Evans — entities, value objects, aggregates, repositories, bounded contexts.
• Implementing Domain-Driven Design, Vaughn Vernon — practical DDD: value objects (ch. 6), aggregates (ch. 10), repositories (ch. 12).
• Architecture Patterns with Python, Percival & Gregory — repository pattern, ports & adapters, service layer, message bus, event-driven integration. Use for: most System Designer lessons.
• Fluent Python, Luciano Ramalho — protocols, ABCs, generators, higher-order functions, context managers.
• Effective Python, Brett Slatkin — idioms: generators, composition, exceptions, concurrency.
• Designing Data-Intensive Applications, Martin Kleppmann — reliability, consistency, availability, stream processing, transactions.
• Release It!, Michael Nygard — stability patterns, fail-fast, circuit breakers, concurrency.
• Building Evolutionary Architectures, Ford, Parsons & Kua — incremental change, fitness functions.
• Monolith to Microservices, Sam Newman — strangler fig, decomposition.
• Software Architecture in Practice, Bass, Clements & Kazman — quality attributes and trade-off analysis (ATAM).
• Team Topologies, Skelton & Pais — team boundaries, cognitive load, coordination.
• Test-Driven Development by Example, Kent Beck — the discipline of correctness via tests.
• Robust Python, Patrick Viafore — Python-specific error handling and typing discipline.
• Continuous Discovery Habits, Teresa Torres — outcomes, opportunity mapping, assumptions, and continuous product discovery.
• User Story Mapping, Jeff Patton — shared understanding, workflow maps, release slices, and discovery through stories.
• Specification by Example, Gojko Adzic — collaborative examples that connect business rules, acceptance, and tests.
• Introducing EventStorming, Alberto Brandolini — collaborative discovery of events, commands, policies, hotspots, and domain boundaries.
• Gamestorming, Gray, Brown & Macanufo, and Sprint, Knapp, Zeratsky & Kowitz — structured divergence, facilitation, convergence, and decision workshops.
• Inspired, Marty Cagan — product discovery and separating customer problems from requested features.
• Fundamentals of Software Architecture, Richards & Ford, and Software Architecture: The Hard Parts, Ford et al. — architecture characteristics, styles, trade-offs, and decision records.
• Growing Object-Oriented Software, Guided by Tests, Freeman & Pryce — walking skeletons and growing an end-to-end system through feedback.
• Accelerate, Forsgren, Humble & Kim, and The DevOps Handbook, Kim et al. — small batches, delivery performance, telemetry, and operational learning.
• The Principles of Product Development Flow, Donald Reinertsen — WIP, queues, batch size, and economic sequencing.
• Thinking in Systems, Donella Meadows — feedback, delay, and the difference between local output and system outcome.

Articles and talks

• Simple Made Easy, Rich Hickey (talk) — the cost of "easy" vs "simple"; foundational for all Master Designer trade-off lessons.
• Tell, Don't Ask (Martin Fowler)
• Strangler Fig Application (Martin Fowler)
• Technical Debt (Martin Fowler)
• Bounded Context (Martin Fowler)
• Convention over Configuration (The Rails Doctrine)
• What Do You Mean by Event-Driven? (Martin Fowler)
• Event Sourcing (Martin Fowler)
• Choose Boring Technology (Dan McKinley)
• Hexagonal Architecture (Alistair Cockburn) — the origin of Ports & Adapters.
• Please stop calling databases CP or AP (Martin Kleppmann) — why CAP is a framing, not a trilemma for choosing products.
• The Wrong Abstraction (Sandi Metz) — duplication is cheaper than the wrong abstraction.
• The Twelve-Factor App — Config — configuration vs convention applied.
• Python typing.Protocol docs — structural subtyping reference.
• Python functional programming HOWTO — generators, iterators, higher-order functions.
• itertools reference — building blocks for streaming pipelines.
• Refactoring Guru — pattern and code-smell reference with motivations.
• The C4 model, Simon Brown — official context, container, component, and supporting diagram guidance.
• Architecture Decision Record, Martin Fowler — short, durable records of context, decision, and ramifications.
• OWASP Threat Modeling Cheat Sheet — model data flows and trust boundaries, ask what can go wrong, choose mitigations, and review.
• Canarying Releases, Google SRE Workbook — partial, time-limited release exposure evaluated against a control.
• Feature Toggles, Pete Hodgson — deployment versus release, flag categories, testing, and carrying cost.

Wisdom (Communities)

• r/softwarearchitecture — discussion of real trade-offs and architecture decisions.
• r/Python — general Python practice; code-review threads.
• Python Software Foundation / local Python meetups — meet people who review real code.
• ArjanCodes community (linked from the mastery waitlist and YouTube channel) — cohort of designers working through the same curriculum; closest match to the wisdom layer of the program.
• Code Review Stack Exchange — structured external review of real code.

Gaps

• Arjan Egges has not (yet) published a book; the flagship written source for the exact mastery curriculum is the course itself plus the sdm GitHub examples. Book recommendations in lessons therefore lean on the classics (Ousterhout, Martin, Evans, Fowler).
• No dedicated high-trust resource found yet for "structural issues in AI-generated code"; until one exists, lessons on that topic lean on primary sources about structure (Ousterhout ch. 16, Feathers) and the learner's own practice.

This page is generated from RESOURCES.md in the repository root, which remains the source of truth.