Curated Reading Companion

You do not need to read ten 600-page books cover-to-cover before writing code. Great engineers read surgically: they pair the exact chapter of a canonical book with the system they are building that week.

Every lesson in this repository includes a ## Reading Companion block referencing specific chapters from the books below.

1. Core Language & Computer Science (Phases 0 & 1)

Fluent Python (2nd Edition) — Luciano Ramalho

• Why it's here: The definitive guide to writing idiomatic, high-performance Python rather than "Java/C translated into Python syntax."
• Where we use it:
• Phase 0, Mod 03: Ch. 1 (The Python Data Model), Ch. 6 (Object References, Mutability, and Recycling), Ch. 8 & 15 (Type Hints & Protocols), Ch. 17 (Iterators, Generators, and Classic Coroutines).
• Phase 2, Mod 02: Ch. 19–21 (Concurrency Models, Concurrent Executors, Asynchronous Programming).

How Linux Works (3rd Edition) — Brian Ward

• Why it's here: Backend code runs on Linux. When a container OOMs, a port is stuck, or file descriptors exhaust, framework docs won't save you.
• Where we use it:
• Phase 0, Mod 01: Ch. 2 (Basic Commands & Directory Hierarchy), Ch. 3 (Devices & Filesystems), Ch. 8 (Processes & Resource Utilization).

Grokking Algorithms (2nd Edition) — Aditya Y. Bhargava

• Why it's here: Fast, visual intuition for Big-O, hash tables, recursion, BFS/DFS, and dynamic programming without heavy mathematical notation.
• Where we use it:
• Phase 1, Mod 01 & 02: Ch. 1–7 (Binary Search, Arrays/Lists, Recursion, Quicksort, Hash Tables, Breadth-First Search).

Architecture Patterns with Python (Cosmic Python) — Harry Percival & Bob Gregory

• Why it's here: Free online (cosmicpython.com). The gold standard for learning TDD, Domain Modeling, Repository Pattern, Unit of Work, and Event-Driven Architecture in Python with SQLAlchemy and FastAPI/Flask.
• Where we use it:
• Phase 0, Mod 04 & Phase 1, Mod 03: Part 1 ( Chapters 1–7: Domain Modeling, Repository, Service Layer, Unit of Work).
• Phase 4, Mod 03: Part 2 (Event-Driven Architecture, Message Bus, CQRS).

2. Networking, Databases & Web Frameworks (Phases 2 & 3)

HTTP: The Definitive Guide (Gourley & Totty) & High Performance Browser Networking (Ilya Grigorik)

• Why they're here: HTTP: The Definitive Guide explains HTTP semantics (headers, methods, proxies, caching) better than any modern blog. HPBN (free at hpbn.co) adds modern TCP internals, TLS 1.3, HTTP/2, HTTP/3, and SSE/WebSockets.
• Where we use them:
• Phase 2, Mod 01: TCP Handshake & Congestion Control, TLS Handshake, HTTP Semantics, Caching & Content Negotiation, Server-Sent Events.

SQL Performance Explained — Markus Winand

• Why it's here: Under 200 pages (use-the-index-luke.com). It teaches you more about how PostgreSQL actually executes queries and uses B-Tree indexes than a 1,000-page database textbook.
• Where we use it:
• Phase 3, Mod 01 & 02: Ch. 1 (Anatomy of an Index), Ch. 2 (The WHERE Clause & Composite Indexes), Ch. 3 (Performance and Scalability), Ch. 6 (Sorting and Grouping — Keyset Pagination).

Two Scoops of Django / Django Documentation (Topic Guides)

• Why it's here: Best practices for structuring enterprise Django applications, QuerySet optimization, custom managers, and DRF patterns.
• Where we use it:
• Phase 3, Mod 04: Models & Database design, QuerySet evaluation & select_related/prefetch_related, Admin customization, REST APIs.

3. Distributed Systems, Data & System Design (Phases 4 & 5)

Designing Data-Intensive Applications (DDIA) — Martin Kleppmann

• Why it's here: The single most important book in modern backend engineering. Reading and applying DDIA separates Junior/Mid developers from Senior/Staff engineers.
• Where we use it:
• Phase 3, Mod 01: Ch. 2 (Data Models), Ch. 3 (Storage and Retrieval: B-Trees vs LSM-Trees), Ch. 7 (Transactions, ACID & Weak Isolation Levels).
• Phase 4, Mod 01–05: Ch. 4 (Encoding and Evolution: Protobuf/gRPC), Ch. 5 (Replication), Ch. 6 (Partitioning), Ch. 8 (The Trouble with Distributed Systems), Ch. 11 (Stream Processing & Message Brokers).

System Design Interview — An Insider's Guide (Vol. 1 & Vol. 2) — Alex Xu

• Why it's here: Practical blueprints for back-of-the-envelope capacity math, rate limiters, consistent hashing, notification engines, and distributed queues.
• Where we use it:
• Phase 4 & Phase 5, Mod 04: Rate Limiter design, Unique ID generator, Notification system, Distributed Message Queue, Metrics & Monitoring system.

Building Microservices (2nd Edition) — Sam Newman

• Why it's here: Teaches you when not to use microservices, how to define bounded contexts, and how to handle distributed transactions (Sagas) and observability.
• Where we use it:
• Phase 4, Mod 05 & Phase 5, Mod 03: Splitting the Monolith, Inter-Service Communication, Sagas, and Observability pillars.