1. Introduction
  2. Nomenclature
  6. Part 1: Foundation
  7. The machine model
    ❱
    1. Solutions
  8. Numbers and how they fit
    ❱
    1. Solutions
  9. The Vec is a table
    ❱
    1. Solutions
  10. Cost is layout, and you have a budget
    ❱
    1. Solutions
  12. Part 2: Identity & structure
  13. Identity is an integer
    ❱
    1. Solutions
  14. A row is a tuple
    ❱
    1. Solutions
  15. Structure of arrays (SoA)
    ❱
    1. Solutions
  16. Where there's one, there's many
    ❱
    1. Solutions
  17. Sort breaks indices
    ❱
    1. Solutions
  18. Stable IDs and generations
    ❱
    1. Solutions
  20. Part 3: Time & passes
  21. The tick
    ❱
    1. Solutions
  22. Event time vs tick time
    ❱
    1. Solutions
  23. A system is a function over tables
    ❱
    1. Solutions
  24. Systems compose into a DAG
    ❱
    1. Solutions
  25. State changes between ticks
    ❱
    1. Solutions
  26. Determinism by order
    ❱
    1. Solutions
  28. Part 4: Existence-based processing
  29. Presence replaces flags
    ❱
    1. Solutions
  30. Add/remove = insert/delete
    ❱
    1. Solutions
  31. EBP dispatch
    ❱
    1. Solutions
  32. Empty tables are free
    ❱
    1. Solutions
  34. Part 5: Memory & lifecycle
  35. swap_remove
    ❱
    1. Solutions
  36. Mutations buffer; cleanup is batched
    ❱
    1. Solutions
  37. Index maps
    ❱
    1. Solutions
  38. Append-only and recycling
    ❱
    1. Solutions
  39. One writer, many readers
    ❱
    1. Solutions
  41. Part 6: Scale
  42. Subscription tables, keyed by slot
    ❱
    1. Solutions
  43. Working set vs cache
    ❱
    1. Solutions
  44. Proximity is a property of position
    ❱
    1. Solutions
  45. The wall at 10K → 1M
    ❱
    1. Solutions
  46. Moving beyond the wall
    ❱
    1. Solutions
  48. Part 7: Concurrency
  49. Disjoint write-sets parallelize freely
    ❱
    1. Solutions
  50. Partition, don't lock
    ❱
    1. Solutions
  51. False sharing
    ❱
    1. Solutions
  52. Order is the contract
    ❱
    1. Solutions
  54. Part 8: I/O & persistence
  55. The boundary is the queue
    ❱
    1. Solutions
  56. Persistence is table serialization
    ❱
    1. Solutions
  57. The log is the world
    ❱
    1. Solutions
  58. Storage systems: bandwidth and IOPS
    ❱
    1. Solutions
  60. Part 9: System of systems
  61. System of systems
    ❱
    1. Solutions
  63. Part 10: Discipline
  64. Mechanism vs policy
    ❱
    1. Solutions
  65. Deferred abstraction
    ❱
    1. Solutions
  66. You can only fix what you wrote
    ❱
    1. Solutions
  67. Tests are systems; TDD from day one
    ❱
    1. Solutions
  69. Act one closes
  70. What you have built
  72. Part 11: Living with it
  73. Living with it
  75. Part 12: Operations
  76. The log survives power loss
    ❱
    1. Solutions
  77. Observation is a read-only system
    ❱
    1. Solutions
  78. Reductions don't parallelize freely
    ❱
    1. Solutions
  79. The worst case is the only case
    ❱
    1. Solutions
  80. It runs without you
  82. Part 13: Knowing the limits
  83. Knowing the limits
  84. Flattening a tree is compiling it
    ❱
    1. Solutions
  85. Staleness flows downhill
    ❱
    1. Solutions
  86. A spreadsheet is a dependency graph
    ❱
    1. Solutions
  87. The same numbers, a different total
    ❱
    1. Solutions
  88. The ceiling is bandwidth, not cores
    ❱
    1. Solutions
  90. Closure
  91. What cannot happen
  95. For lecturers
  96. Concept DAG
  97. Glossary
  98. Simulator specification