Daniel Collin’s slide deck makes one argument and spends 77 slides making it: in game code, the cost of a loop is mostly the cost of getting to the bytes, not the arithmetic. A main-memory read is roughly 600 cycles; a register is 1–2. Once you accept that ratio, layout stops being a style preference.

The whole case rests on a single example. An object-oriented Bot class computes m_aimDirection = dot3(m_position, target) * m_mod;. Run that across four bots and the deck tallies:

  • i-cache miss ~600 cycles, m_position ~600, m_mod ~600, aimDir ~100, arithmetic ~20
  • 7,680 cycles for four bots
  • Each object load drags in cache lines holding data the function never reads

Rewrite the identical math as a loop over parallel arrays and the same four bots cost 1,980 cycles — roughly 4x less, with the arithmetic unchanged. What changed is only that the loop reads just the inputs it needs, writes into a linear array, and walks the data front to back.

The rule he derives from it is “design back to front”: decide the output data you need, then add the minimum input data required to produce it. Three consequences fall out of that:

  • Threading becomes possible. You cannot parallelise what you cannot describe; without knowing which data a function touches, splitting work means locks, and locks protect data, not code.
  • Offload becomes possible. Unknown access patterns make it hard or impossible to run a system on a co-unit.
  • Code gets easier to test. Isolated, interchangeable data and small transforms on it are testable in a way tangled object graphs are not.

The deck is also not only theory. Its area-trigger example converts a linked list of positions into flat arrays plus a count, on the principle that source data and runtime data do not need the same shape. A culling rewrite using linear arrays and brute force came out 3x faster, one fifth the code size, and simpler.

The most transferable idea is that one — pre-format the data, pick a memory layout that suits the access pattern rather than inheriting the one you loaded from disk. It is ordinary engine practice now and was not in 2010, which is why a PS3-era deck resurfaced on Hacker News in July 2026 at 255 points.

Worth keeping the scope honest: this is a claim about hot loops in games, not a general software-design argument. Data-oriented design applied to code that is not hot buys complexity for nothing.