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.
• Applying UML and Patterns, Craig Larman — the complete analysis-to-design path: use cases, domain models, system sequence diagrams, operation contracts, GRASP responsibilities, state machine diagrams, logical architecture. Use for: the System Architect phase foundation (0051–0060).
• Design It!, Michael Keeling — blank-canvas architecture: stakeholders, goals, requirements, constraints, quality attributes, architectural responsibilities, modeling, and evaluation. Use for: the System Architect phase.
• Object Design: Roles, Responsibilities, and Collaborations, Wirfs-Brock & McKean — responsibility-driven design: finding objects, assigning responsibilities, collaborations, contracts, and control style. Use for: boundaries and components (0053, 0056).
• Learning Domain-Driven Design, Vlad Khononov — optional deep-dive for DDD vocabulary (subdomains, bounded contexts, aggregates, event sourcing); not required for the course's foundation.
• 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.
• API Design Patterns, JJ Geewax — resource-oriented API contracts: naming, resource hierarchy, standard and custom methods, versioning, validation, retries, and revisions. Use for: contract design (0057).
• 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.
• Continuous Delivery, Humble & Farley — the deployment pipeline, environments, build and deployment scripting, release strategies, data management, and component dependencies. Use for: deployment and release design (0060).
• 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.

Sources for the capstone, code lab, cases, and supplements

Several of these also appear in the book list above; here they carry a link and the specific page that leans on them.

• Working Effectively with Legacy Code, Michael Feathers
  Seams and sensing points (ch. 4), getting a class into a test harness (ch. 9–10), characterization tests (ch. 13), "I don't understand this code well enough to change it" (ch. 16). Use for: the brownfield modernization case and the code lab's characterization-test checkpoints.
• Strangler Fig Application (Martin Fowler)
  Growing the replacement around the edges of a live system rather than rewriting it. Use for: the brownfield modernization case.
• Branch By Abstraction (Martin Fowler)
  Making a large change incrementally on the mainline, behind an abstraction that both implementations satisfy. Use for: the brownfield case, and stability vs speed of change (0035).
• Team Topologies, Skelton & Pais
  Stream-aligned, platform, enabling and complicated-subsystem teams; cognitive load as a design constraint; the three interaction modes. Use for: the multi-team architecture supplement — team APIs, Conway's law, cross-team contracts.
• The Principles of Product Development Flow, Donald Reinertsen
  Cost of delay, queueing, batch size, WIP constraints, and economic sequencing (ch. 2–7). Use for: the architecture economics supplement, and delivery sequencing in lessons 0047–0048.
• Threat Modeling: Designing for Security, Adam Shostack
  The four-question frame, STRIDE, data-flow diagrams and trust boundaries, and how to run the workshop with a whole team. Use for: the security, privacy and accessibility supplement.
• OWASP Application Security Verification Standard (ASVS)
  Leveled, testable security requirements — including object-level authorization and multi-tenant isolation. Use for: abuse cases and negative acceptance examples.
• Web Content Accessibility Guidelines (WCAG) 2.2
  The normative success criteria behind an "AA" commitment. Use for: accessibility as an architecture and acceptance concern — the returns-resolution case's WCAG 2.2 AA guardrail.
• Release It! (2nd ed.), Michael Nygard
  Stability antipatterns and patterns, circuit breakers, bulkheads, and designing for production rather than for the demo. Use for: the code lab's unsafe-retry checkpoint and the rollout lessons.
• Designing Data-Intensive Applications, Martin Kleppmann
  Replication, partitioning, transactions, consistency models, and stream processing. Use for: consistency vs availability (0032) and the capstone's data-ownership decisions.
• Monolith to Microservices, Sam Newman
  Decomposition patterns, database decomposition, expand/contract, and the chapter on when not to split. Use for: the brownfield case's "deciding when not to extract a service".
• Building Evolutionary Architectures, Ford, Parsons & Kua
  Fitness functions, incremental change, and architectural characteristics that can be measured continuously. Use for: the code lab's fitness functions and lesson 0022's enforced import table.

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.