Software Architecture

Appearance

Primary Sources ​

The course teaches in its own words, distilled from a working set of architecture books. This file collects the primary and foundational sources behind the ideas — the seminal papers and canonical texts — for readers who want to go past the distillation to the originals. Each chapter's "Going deeper" section points to the ones relevant to it; this is the consolidated map.

Two notes:

  • These complement, not replace, the trade books the course draws on (Fundamentals of Software Architecture; Software Architecture: The Hard Parts; Building Microservices; Designing Data-Intensive Applications; Node.js Design Patterns; Domain-Driven Design in PHP).
  • The Tier 2 stack tracks (Nuxt, Laravel) are largely current-ecosystem practice that the foundational literature predates; primary sources there are listed where a genuine one underpins the idea, and are sparser by nature.

The canonical core ​

A handful of these recur across chapters because the whole course rests on them. If you read only a few, read these:

  • D. L. Parnas, On the Criteria To Be Used in Decomposing Systems into Modules — Communications of the ACM, 1972. The origin of "modularity is about hiding decisions behind boundaries" — the idea under every boundary in this course.
  • M. E. Conway, How Do Committees Invent? — Datamation, 1968. Conway's Law.
  • E. F. Codd, A Relational Model of Data for Large Shared Data Banks — Communications of the ACM, 1970. The relational model.
  • Seth Gilbert & Nancy Lynch, Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services — ACM SIGACT News, 2002 (proving Eric Brewer's 2000 PODC CAP conjecture). CAP, precisely — where "consistency" means linearizability.
  • Leslie Lamport, Time, Clocks, and the Ordering of Events in a Distributed System — Communications of the ACM, 1978. Why "what happened first" is hard across machines.
  • Eric Evans, Domain-Driven Design: Tackling Complexity in the Heart of Software — Addison-Wesley, 2003. Aggregates, bounded contexts, the domain model.
  • Martin Fowler, Patterns of Enterprise Application Architecture — Addison-Wesley, 2002. Repository, Service Layer, Unit of Work, Active Record vs. Data Mapper.

A companion at a different altitude ​

One book sits slightly outside the structure above and is worth calling out on its own terms:

  • John Ousterhout, A Philosophy of Software Design — Yaknyam Press, 2018 (2nd ed. 2021). A short, opinionated book about software design at the class-and-method altitude — one level below the system-architecture scale this course mostly works at. It isn't a seminal primary source the way Parnas or Codd are; it's a modern distillation, an experienced practitioner's field notes. It earns a place here because its core thesis is the direct descendant of Parnas (1972): complexity is the enemy, it comes from dependencies and obscurity, and the cure is deep modules — simple interfaces over substantial, hidden implementations. That's the same idea this course builds its boundaries on, stated one altitude down, which is exactly why it's a useful companion: it sharpens the code-level instincts the architecture-level decisions rest on.

    Where the course threads it in (the ideas are taught in the course's own words, attributed inline):

    • Complexity = dependencies + obscurity, and the strategic-vs-tactical / 10–20% continuous-investment mindset — Foundations Ch 1.
    • Define errors out of existence (design the condition away rather than handle it) — Foundations Ch 4.
    • Information leakage as the diagnostic for a bad decomposition — Foundations Ch 5.
    • Complexity is incremental ("sweat the small stuff") as the case for continuous governance — Foundations Ch 6.
    • Deep vs. shallow modules and the pass-through smell — applied to Nitro services (Tier 2a Ch 4) and Laravel service/action layers (Tier 2b Ch 2); rich entities as deep modules (Tier 2b Ch 3).
    • Dependencies + obscurity as a second lens for comparing how two stacks express the same decision — Tier 3 Ch 1.

    For the originals beneath it, read Parnas (1972) and Brooks, No Silver Bullet (1987) — Ousterhout is, in large part, those two ideas carried into a modern codebase.

Tier 1 — Foundations ​

Ch 1 · Architecture as Tradeoffs

  • Fred Brooks, No Silver Bullet — Essence and Accident in Software Engineering — IEEE Computer, April 1987.
  • D. L. Parnas, On the Criteria To Be Used in Decomposing Systems into Modules — CACM, 1972.
  • M. E. Conway, How Do Committees Invent? — Datamation, 1968.

Ch 2 · Architectural Styles

  • M. E. Conway (1968) and D. L. Parnas (1972), as above — styles follow boundaries and the org chart.
  • James Lewis & Martin Fowler, Microservices — martinfowler.com, 2014.

Ch 3 · Data Fundamentals

  • E. F. Codd, A Relational Model of Data for Large Shared Data Banks — CACM, 1970.
  • Theo Härder & Andreas Reuter, Principles of Transaction-Oriented Database Recovery — ACM Computing Surveys, 1983 (the paper that coined "ACID").
  • Seth Gilbert & Nancy Lynch, Brewer's Conjecture… — SIGACT News, 2002 (Brewer's CAP conjecture, PODC 2000).

Ch 4 · Reliability Patterns

  • The Fallacies of Distributed Computing — L. Peter Deutsch and colleagues at Sun Microsystems, c. 1994–97 (later annotated by Arnon Rotem-Gal-Oz).
  • Leslie Lamport, Time, Clocks, and the Ordering of Events in a Distributed System — CACM, 1978.
  • Michael Nygard, Release It! — Pragmatic Bookshelf, 2007 (2nd ed. 2018) — circuit breakers, timeouts, stability patterns.

Ch 5 · Communication Patterns

  • Gregor Hohpe & Bobby Woolf, Enterprise Integration Patterns — Addison-Wesley, 2003.
  • Hector Garcia-Molina & Kenneth Salem, Sagas — ACM SIGMOD, 1987.
  • Pat Helland, Life Beyond Distributed Transactions: An Apostate's Opinion — CIDR, 2007.

Ch 6 · Architecture Governance

  • Michael Nygard, Documenting Architecture Decisions — 2011 (the ADR format).
  • Neal Ford, Rebecca Parsons & Patrick Kua, Building Evolutionary Architectures — O'Reilly, 2017 (2nd ed. 2023, with Pramod Sadalage) — fitness functions.
  • Conway (1968) and Parnas (1972), as above.

Tier 2a — JS/TS Fullstack (Nuxt) ​

Largely current-ecosystem; primary sources where the underlying idea has one.

  • Ch 1 · Type-Safe Fullstack Boundaries — Alexis King, Parse, Don't Validate — 2019.
  • Ch 2 · Rendering & Execution Model — Douglas C. Schmidt, Reactor: An Object Behavioral Pattern for Concurrent Event Demultiplexing and Dispatching — in Pattern Languages of Program Design, Addison-Wesley, 1995 (the event-loop pattern).
  • Ch 3 · The Data-Fetching Boundary — Roy T. Fielding, Architectural Styles and the Design of Network-based Software Architectures (REST) — Ph.D. dissertation, UC Irvine, 2000; Phil Calçado, The Back-end for Front-end Pattern (BFF) — 2015.
  • Ch 4 · API & Server Routes (Nitro) — Fielding, REST dissertation, 2000.
  • Ch 5 · State Management & Persistence — Gilbert & Lynch (2002) and Härder & Reuter (1983), as in Tier 1 — consistency and ACID, in their fullstack form.
  • Ch 6 · Async Workflows — Garcia-Molina & Salem, Sagas (1987); Helland, Life Beyond Distributed Transactions (2007).
  • Ch 7 · Testing the Fullstack — Mike Cohn, Succeeding with Agile — Addison-Wesley, 2009 (the test pyramid); Ham Vocke, The Practical Test Pyramid — martinfowler.com, 2018.
  • Ch 8 · Operational Readiness — Betsy Beyer, Chris Jones, Jennifer Petoff & Niall Richard Murphy (eds.), Site Reliability Engineering — O'Reilly, 2016 (the golden signals).

Tier 2b — PHP/Laravel ​

Laravel-framed, but the principles have strong primary sources.

  • Ch 1 · Modern PHP Foundations — Evans, DDD (2003); Fowler, PoEAA (2002).
  • Ch 2 · Laravel Architecture Boundaries — Evans, DDD (2003, the layered-architecture chapter); Fowler, PoEAA (2002, Service Layer & Repository).
  • Ch 3 · Domain Modeling & DDD-lite — Evans, DDD (2003); Vaughn Vernon, Implementing Domain-Driven Design — Addison-Wesley, 2013 (small-aggregate rules); Fowler, PoEAA (2002, Active Record vs. Data Mapper — the Eloquent/DDD tension).
  • Ch 4 · Data Consistency in Laravel — Fowler, PoEAA (2002, Unit of Work, Optimistic/Pessimistic Offline Lock); Jim Gray & Andreas Reuter, Transaction Processing: Concepts and Techniques — Morgan Kaufmann, 1992.
  • Ch 5 · Laravel Async Patterns — Hohpe & Woolf, Enterprise Integration Patterns (2003, Idempotent Receiver, Dead Letter Channel); Nygard, Release It! (2007/2018).
  • Ch 6 · Security & Validation — OWASP Top Ten (current edition: 2021; 2025 revision published); Jerome H. Saltzer & Michael D. Schroeder, The Protection of Information in Computer Systems — Proceedings of the IEEE, 1975 (least privilege, complete mediation, fail-safe defaults).
  • Ch 7 · Testing in Laravel — Kent Beck, Test-Driven Development: By Example — Addison-Wesley, 2002; Mike Cohn, Succeeding with Agile (2009).

Tier 3 — Synthesis + Capstone ​

  • Ch 1 · Cross-Stack Synthesis — Martin Fowler, PoEAA (2002, patterns that recur across frameworks — the architecture-survives-the-stack thesis); Parnas (1972, boundaries as architecture); Neal Ford, Mark Richards, Pramod Sadalage & Zhamak Dehghani, Software Architecture: The Hard Parts — O'Reilly, 2021.
  • Ch 2 · The Capstone — Evans, DDD (2003, the boundary you draw); Hohpe & Woolf, Enterprise Integration Patterns (2003, sagas/choreography); The Hard Parts (2021, decomposition). For the deterministic-vs-AI axis, the current-ecosystem references are cited inline in the chapter (Karpathy; Anthropic, Building Effective Agents — the workflow-vs-agent distinction, the augmented-LLM building block, and the five composable patterns; Husain; Cherny) and flagged as outside the book set. Two book-length, architecture-focused follow-ons for that axis: Chip Huyen, AI Engineering (O'Reilly, 2025 — eval methodology and the guardrails → router → cache → agent → observability build as design decisions) and Suhas Pai, Designing Large Language Model Applications (O'Reilly, 2025 — RAG pipelines, agentic systems, multi-LLM cascades/routers). Both go far deeper than the course's light threading and are foundation-model-specific.