Curriculum

Historical manuscript reference. Numbering, prerequisite claims, and verification below describe the original eight-module import. For the current ten-stage path and teaching-review status, use the learning path and course outline.

Audience and outcome

The reader can program and write basic SQL but need not have studied operating systems, networks, or database implementation. The course develops a design vocabulary and follows enough mechanism detail to make implementation choices reviewable. It covers engines first and production applications second. It does not equate completion of reading with demonstrated production competence.

Progression

Parts I–II establish cost models and physical representation. Part III turns declarative requests into execution. Part IV adds atomicity, isolation, concurrency, and recovery. Part V extends correctness across unreliable machines. Part VI combines distribution with scaling and state delivery. Part VII treats the surrounding application and operational responsibilities. Part VIII compares published systems and carries three workloads through a complete architecture evolution.

Dependencies

The diagram shows conceptual prerequisites. Reading order also introduces examples progressively. Later chapters revisit earlier mechanisms under a larger failure model; those revisits add a new responsibility rather than changing earlier definitions.

External coverage checks

Three university curricula serve as independent checks on topic selection. They are references for coverage, not an accreditation or a claim that this manuscript replaces their implementation work.

These checks preserve the course’s stated emphasis. Routing protocols, cryptographic implementation, Byzantine consensus, blockchain systems, and general distributed-compute frameworks require separate specialist study; they are not silently treated as covered in full. This manuscript concentrates on transactional database design under concurrency, delay, and primarily crash or omission failures, while explaining the boundary of that failure model.

Detailed curriculum

01. Workloads and correctness contracts

Part 1. Prerequisite: Basic programming and SQL; no systems background required.

Coverage: OLTP, OLAP, mixed workloads, skew, contention, invariants, workload envelopes.

Separate business arrivals, attempts, successful commits, and changes delivered; establish the ownership and stock invariants before choosing a topology.

01. Workloads and correctness contracts · 01. Workloads and correctness contracts

02. Hardware and operating-system costs

Part 1. Prerequisite: Lesson 01: Workloads and correctness contracts, plus the earlier dependency chain.

Coverage: CPU caches, RAM, NUMA, SSDs, page cache, system calls, copying, persistence boundaries.

Trace one read from a CPU instruction through address translation and caches; contrast a buffered write with a durable one.

02. Hardware and operating-system costs · 02. Hardware and operating-system costs

03. Local concurrency and execution

Part 1. Prerequisite: Lesson 02: Hardware and operating-system costs, plus the earlier dependency chain.

Coverage: processes, threads, event loops, scheduling, synchronization, concurrency, parallelism.

Follow ownership of a request through accept, queue, runnable work, blocking work, and completion; locate synchronization boundaries.

03. Local concurrency and execution · 03. Local concurrency and execution

04. Networking and transport

Part 1. Prerequisite: Lesson 03: Local concurrency and execution, plus the earlier dependency chain.

Coverage: DNS, routing, sockets, TCP, UDP, QUIC, TLS, congestion, flow control, loss, head-of-line blocking.

Trace connection establishment and steady-state data separately; distinguish ordering, retransmission, congestion control, and receiver flow control.

04. Networking and transport · 04. Networking and transport

05. Application protocols and remote calls

Part 1. Prerequisite: Lesson 04: Networking and transport, plus the earlier dependency chain.

Coverage: framing, serialization, RPC, HTTP, WebSockets, pooling, timeouts, retries, cancellation, idempotency.

Walk through request identity, transactionally recorded results, response framing, and bounded retry behavior.

05. Application protocols and remote calls · 05. Application protocols and remote calls

06. Performance reasoning

Part 1. Prerequisite: Lesson 05: Application protocols and remote calls, plus the earlier dependency chain.

Coverage: latency budgets, throughput, percentiles, queueing, utilization, Little’s Law, Amdahl’s Law, coordinated omission.

Derive a resource ceiling, apply queueing assumptions explicitly, and compare open-loop with closed-loop measurement.

06. Performance reasoning · 06. Performance reasoning

07. Logical models and schemas

Part 2. Prerequisite: Lesson 06: Performance reasoning, plus the earlier dependency chain.

Coverage: relational algebra, keys, constraints, joins, normalization, denormalization, documents, key-value models.

Express facts and functional dependencies; distinguish logical constraints from physical indexes.

07. Logical models and schemas · 07. Logical models and schemas

08. Physical representation

Part 2. Prerequisite: Lesson 07: Logical models and schemas, plus the earlier dependency chain.

Coverage: records, pages, heaps, slotted pages, row layout, column layout, encoding, compression, fragmentation.

Draw a page, account for headers and slots, then explain versioned formats and safe bounds checking.

08. Physical representation · 08. Physical representation

09. Memory and buffer management

Part 2. Prerequisite: Lesson 08: Physical representation, plus the earlier dependency chain.

Coverage: buffer pools, eviction, pinning, dirty pages, prefetch, direct I/O, mmap, working sets.

Trace hit, miss, pin, eviction, writeback, and I/O completion; separate replacement from durability ordering.

09. Memory and buffer management · 09. Memory and buffer management

10. Tree and hash indexes

Part 2. Prerequisite: Lesson 09: Memory and buffer management, plus the earlier dependency chain.

Coverage: B+ trees, hashing, composite keys, covering indexes, range scans, splits, index maintenance.

Trace lookup, leaf traversal, split publication, and a hash lookup; connect physical order to query shape.

10. Tree and hash indexes · 10. Tree and hash indexes

11. Log-structured storage

Part 2. Prerequisite: Lesson 10: Tree and hash indexes, plus the earlier dependency chain.

Coverage: memtables, SSTables, Bloom filters, compaction, tombstones, amplification.

Follow a mutation through log, memtable, flush, manifest, and compaction; derive when tombstones can be removed safely.

11. Log-structured storage · 11. Log-structured storage

12. Specialized access paths

Part 2. Prerequisite: Lesson 11: Log-structured storage, plus the earlier dependency chain.

Coverage: columnar access, inverted indexes, time series, spatial indexing, vector search, approximation.

Explain each access path’s candidate reduction and residual checking; distinguish exact results from recall tradeoffs.

12. Specialized access paths · 12. Specialized access paths

13. Query front end

Part 3. Prerequisite: Lesson 12: Specialized access paths, plus the earlier dependency chain.

Coverage: parsing, binding, type checking, catalogs, SQL nulls, logical plans.

Transform SQL into a typed plan while preserving names, types, parameters, privileges, and schema dependencies.

13. Query front end · 13. Query front end

14. Logical optimization

Part 3. Prerequisite: Lesson 13: Query front end, plus the earlier dependency chain.

Coverage: predicate pushdown, projection, join transformations, decorrelation, equivalence, semantic constraints.

Prove a safe inner-join rewrite using bag and null semantics, then construct the outer-join counterexample.

14. Logical optimization · 14. Logical optimization

15. Physical operators

Part 3. Prerequisite: Lesson 14: Logical optimization, plus the earlier dependency chain.

Coverage: scans, nested-loop joins, hash joins, merge joins, sorting, aggregation, spilling.

Trace operator state, cardinality, blocking behavior, memory ownership, and external execution.

15. Physical operators · 15. Physical operators

16. Cost-based planning

Part 3. Prerequisite: Lesson 15: Physical operators, plus the earlier dependency chain.

Coverage: statistics, cardinality, skew, correlation, plan cache, parameter sensitivity, adaptive execution.

Derive estimated cardinalities, expose correlation error, and describe plan alternatives without equating cost units to milliseconds.

16. Cost-based planning · 16. Cost-based planning

17. Execution engines

Part 3. Prerequisite: Lesson 16: Cost-based planning, plus the earlier dependency chain.

Coverage: iterator, vectorized execution, compilation, SIMD, parallel execution, async execution, materialization.

Compare control flow and data flow through row-at-a-time, batched, and compiled pipelines.

17. Execution engines · 17. Execution engines

18. Computation boundaries

Part 3. Prerequisite: Lesson 17: Execution engines, plus the earlier dependency chain.

Coverage: embedded databases, database servers, stored procedures, sandboxing, modules, serialization, locality.

Compare the same invariant and durability contract across process boundaries; trace where waiting occupies ownership.

18. Computation boundaries · 18. Computation boundaries

19. Atomic transactions and logging

Part 4. Prerequisite: Lesson 18: Computation boundaries, plus the earlier dependency chain.

Coverage: transaction states, commit boundaries, undo, redo, WAL, failure ordering.

Define private versus installed writes; distinguish a durable commit decision from page installation.

19. Atomic transactions and logging · 19. Atomic transactions and logging

20. Lock-based concurrency control

Part 4. Prerequisite: Lesson 19: Atomic transactions and logging, plus the earlier dependency chain.

Coverage: two-phase locking, granularity, predicate protection, deadlocks, prevention, fairness.

Build the wait-for cycle, compare victim abort with ordered acquisition, and explain phantom protection.

20. Lock-based concurrency control · 20. Lock-based concurrency control

21. Multiversion concurrency control

Part 4. Prerequisite: Lesson 20: Lock-based concurrency control, plus the earlier dependency chain.

Coverage: versions, snapshots, visibility, snapshot isolation, write skew, serializability, garbage collection.

Trace visible versions and read/write dependencies; explain why disjoint writes can violate a shared invariant.

21. Multiversion concurrency control · 21. Multiversion concurrency control

22. Alternative execution strategies

Part 4. Prerequisite: Lesson 21: Multiversion concurrency control, plus the earlier dependency chain.

Coverage: optimistic control, timestamp ordering, deterministic execution, single-writer, contention.

Compare validation sets, timestamp rules, ordered scheduling, and serialized execution under the same workload.

22. Alternative execution strategies · 22. Alternative execution strategies

23. Concurrent engine internals

Part 4. Prerequisite: Lesson 22: Alternative execution strategies, plus the earlier dependency chain.

Coverage: locks, latches, atomics, memory ordering, concurrent indexes, false sharing, reclamation, NUMA.

Separate logical protection from physical structural safety; show publication and deferred reclamation.

23. Concurrent engine internals · 23. Concurrent engine internals

24. Crash recovery and durable commit

Part 4. Prerequisite: Lesson 23: Concurrent engine internals, plus the earlier dependency chain.

Coverage: replay, checkpoints, torn writes, checksums, flushing, group commit, recovery time.

Walk through analysis, redo, undo where required, and page-integrity handling; define durable acknowledgment.

24. Crash recovery and durable commit · 24. Crash recovery and durable commit

25. Distributed failure models

Part 5. Prerequisite: Lesson 24: Crash recovery and durable commit, plus the earlier dependency chain.

Coverage: partial failure, delayed messages, failure detection, clocks, ordering, duplicates, ambiguity.

Separate suspicion from proof, deadlines from cancellation, and epochs from wall-clock freshness.

25. Distributed failure models · 25. Distributed failure models

26. Distributed consistency

Part 5. Prerequisite: Lesson 25: Distributed failure models, plus the earlier dependency chain.

Coverage: linearizability, serializability, strict serializability, causal, session guarantees, CAP, PACELC.

Construct legal histories for each guarantee and identify the availability decision during a partition.

26. Distributed consistency · 26. Distributed consistency

27. Replication strategies

Part 5. Prerequisite: Lesson 26: Distributed consistency, plus the earlier dependency chain.

Coverage: leader/follower, quorums, leaderless, sync, async, stale reads, repair, divergence.

Trace write acknowledgment and read paths; state why quorum intersection alone is insufficient for full linearizability.

27. Replication strategies · 27. Replication strategies

28. Consensus and leadership

Part 5. Prerequisite: Lesson 27: Replication strategies, plus the earlier dependency chain.

Coverage: Raft, Paxos, replicated state machines, elections, terms, fencing, split brain, membership.

Trace a replicated log through failure, election, commitment, and application; distinguish log replication from consensus.

28. Consensus and leadership · 28. Consensus and leadership

29. Partitioning and routing

Part 5. Prerequisite: Lesson 28: Consensus and leadership, plus the earlier dependency chain.

Coverage: hash partitions, ranges, metadata, placement, hotspots, rebalancing, resharding, tenant boundaries.

Follow a split or move with authoritative routing versions and concurrent writes.

29. Partitioning and routing · 29. Partitioning and routing

30. Distributed transactions

Part 5. Prerequisite: Lesson 29: Partitioning and routing, plus the earlier dependency chain.

Coverage: two-phase commit, atomic commit, consensus, distributed MVCC, timestamps, uncertainty, sagas.

Trace durable participant and coordinator states; compare atomic transactions with compensation.

30. Distributed transactions · 30. Distributed transactions

31. Distributed query execution

Part 6. Prerequisite: Lesson 30: Distributed transactions, plus the earlier dependency chain.

Coverage: partition pruning, distributed joins, shuffle, aggregation, stragglers, OLAP priorities.

Compare broadcast, repartition, and colocated joins; push partial aggregation without changing semantics.

31. Distributed query execution · 31. Distributed query execution

32. Caches and maintained results

Part 6. Prerequisite: Lesson 31: Distributed query execution, plus the earlier dependency chain.

Coverage: invalidation, materialized views, incremental computation, CDC, CQRS, freshness.

Trace versioned cache fills and delta maintenance; separate event history from current state.

32. Caches and maintained results · 32. Caches and maintained results

33. Realtime delivery

Part 6. Prerequisite: Lesson 32: Caches and maintained results, plus the earlier dependency chain.

Coverage: pub/sub, snapshots plus updates, ordering, replay, subscriptions, fan-out, backpressure.

Establish a snapshot watermark and ordered catch-up, then bound slow-client state.

33. Realtime delivery · 33. Realtime delivery

34. Tail latency and overload

Part 6. Prerequisite: Lesson 33: Realtime delivery, plus the earlier dependency chain.

Coverage: admission, queues, batching, pipelining, shedding, retry budgets, recovery.

Follow offered, admitted, and completed work; bound queues and reserve capacity for recovery.

34. Tail latency and overload · 34. Tail latency and overload

35. Capacity and multitenancy

Part 6. Prerequisite: Lesson 34: Tail latency and overload, plus the earlier dependency chain.

Coverage: CPU, memory, storage, network, hot keys, isolation, quotas, noisy neighbors, autoscaling.

Build a per-operation resource vector and distinguish spare capacity from isolation.

35. Capacity and multitenancy · 35. Capacity and multitenancy

36. Separated compute and storage

Part 6. Prerequisite: Lesson 35: Capacity and multitenancy, plus the earlier dependency chain.

Coverage: shared nothing, shared storage, remote storage, object storage, tiering, elasticity, cold caches.

Trace data, log, metadata, and cache ownership separately; include remote-failure and recovery paths.

36. Separated compute and storage · 36. Separated compute and storage

37. Application data architecture

Part 7. Prerequisite: Lesson 36: Separated compute and storage, plus the earlier dependency chain.

Coverage: transaction boundaries, access patterns, pools, N+1, outbox, side effects, service boundaries.

Use a transactional outbox and idempotent consumer; explain the remaining ordering and retention responsibilities.

37. Application data architecture · 37. Application data architecture

38. Geographic architecture

Part 7. Prerequisite: Lesson 37: Application data architecture, plus the earlier dependency chain.

Coverage: placement, regional ownership, global reads, global writes, locality, distance, failover.

Draw local and cross-region paths; choose ownership and read freshness based on the contract.

38. Geographic architecture · 38. Geographic architecture

39. Failure recovery and continuity

Part 7. Prerequisite: Lesson 38: Geographic architecture, plus the earlier dependency chain.

Coverage: backup, restore, PITR, repair, failover, disaster recovery, RPO, RTO, correlated failures.

Distinguish hardware failover from logical recovery and calculate the complete recovery path.

39. Failure recovery and continuity · 39. Failure recovery and continuity

40. Security and isolation

Part 7. Prerequisite: Lesson 39: Failure recovery and continuity, plus the earlier dependency chain.

Coverage: authentication, authorization, visibility, encryption, keys, audits, abuse, tenant separation.

Follow identity through every trust boundary; analyze queries, caches, subscriptions, logs, and restore access.

40. Security and isolation · 40. Security and isolation

41. Safe evolution

Part 7. Prerequisite: Lesson 40: Security and isolation, plus the earlier dependency chain.

Coverage: schema changes, online indexes, backfills, compatibility, rolling upgrades, rollback, migration load.

Apply expand, compatible dual operation, backfill, validation, and contract while tracking concurrent writes.

41. Safe evolution · 41. Safe evolution

42. Observability and verification

Part 7. Prerequisite: Lesson 41: Safe evolution, plus the earlier dependency chain.

Coverage: tracing, profiling, SLOs, saturation, load tests, crashes, fault injection, histories.

Connect trace spans to resource metrics and correctness histories; separate measured observations from interpretation.

42. Observability and verification · 42. Observability and verification

43. SQLite and PostgreSQL

Part 8. Prerequisite: Lesson 42: Observability and verification, plus the earlier dependency chain.

Coverage: embedded deployment, server deployment, writer concurrency, persistence, SQL, operations.

Compare equivalent transactions and durable settings; distinguish deployment topology from logical capability.

43. SQLite and PostgreSQL · 43. SQLite and PostgreSQL

44. RocksDB and Cassandra

Part 8. Prerequisite: Lesson 43: SQLite and PostgreSQL, plus the earlier dependency chain.

Coverage: storage engine, distributed database, LSM economics, partitioning, repair.

Assign responsibilities to the storage library and the distributed coordinator, routing, and repair layers.

44. RocksDB and Cassandra · 44. RocksDB and Cassandra

45. Redis and memory-oriented designs

Part 8. Prerequisite: Lesson 44: RocksDB and Cassandra, plus the earlier dependency chain.

Coverage: memory-first execution, command costs, persistence, eviction, clustering, hot keys.

Trace cache and authoritative configurations separately, including restart, fork, expiration, and failover.

45. Redis and memory-oriented designs · 45. Redis and memory-oriented designs

46. Spanner, CockroachDB, and FoundationDB

Part 8. Prerequisite: Lesson 45: Redis and memory-oriented designs, plus the earlier dependency chain.

Coverage: distributed transactions, timestamps, replication, placement, coordination, layering.

Contrast documented architectural mechanisms and historical scope without inventing a universal performance ranking.

46. Spanner, CockroachDB, and FoundationDB · 46. Spanner, CockroachDB, and FoundationDB

47. Contrasting workload priorities

Part 8. Prerequisite: Lesson 46: Spanner, CockroachDB, and FoundationDB, plus the earlier dependency chain.

Coverage: SpacetimeDB, Convex, ClickHouse, realtime state, analytical execution, workload fit.

Map guarantees, computation boundaries, result maintenance, and data layout to the requested workload.

47. Contrasting workload priorities · 47. Contrasting workload priorities

48. A complete architecture walkthrough

Part 8. Prerequisite: Lesson 47: Contrasting workload priorities, plus the earlier dependency chain.

Coverage: local storage, indexes, WAL, concurrency, replication, sharding, overload, operations.

Carry the same invariants through each evolution, state the new failure model, and explain when the architecture must diverge.

48. A complete architecture walkthrough · 48. A complete architecture walkthrough