Unit — Advanced Patterns

01why

Three requirements force enableable components into the chunk header. State them.

1. aSmall, cacheable and serializable
2. bFlipping must not be structural (so it can't live in the archetype), queries must still filter on it (so the query system must see it), and filtering must be cheap in bulk (so it must be contiguous, not scattered per entity)
3. cThread-safe, deterministic and Burst-compatible
4. dZero-cost, mutable and queryable

02why

Why does disabling an enableable component not free its memory?

1. aIt's a known inefficiency in the implementation
2. bThe design requirement was that the entity doesn't move and the archetype doesn't change — but archetype determines chunk layout, so unchanged layout means the space stays allocated. The space is the price of the stability
3. cThe memory is reserved for the bitmask
4. dDisabled entities are copied to a holding chunk

03how

Give the decision rule between tag and enableable, and name the criterion.

1. aAlways prefer enableable; it's strictly more flexible
2. bFlip frequency — tags win when the property is fixed for the entity's life, since zero bytes beats full size and the structural cost is never paid; enableable wins when it flips often enough that repeated chunk moves cost more than the permanent bytes
3. cUse tags for gameplay and enableable for rendering
4. dWhichever produces fewer archetypes

04why

Why is flipping an enableable bit safe inside a parallel job while adding a tag is not?

1. aBit writes are atomic
2. bStructural changes require a command buffer because they invalidate chunk layout mid-iteration; a bit write to the chunk header relocates nothing, so the hazard the ECB protects against doesn't arise
3. cThe safety system has a special case for it
4. dTags can be added in jobs too

05how

Do enableable components restore full chunk-skipping?

1. aYes, identically to archetype matching
2. bNo — an all-disabled chunk is skipped cheaply, but a half-disabled chunk is visited and stepped through. Entity-level filtering with cheap bulk tests: better than a per-entity bool branch, weaker than an archetype that doesn't match at all
3. cNo, they offer no filtering benefit over a bool
4. dOnly for tag-sized components

06what

Define determinism and name the three capabilities that depend on it.

1. aCrash-free execution; stability, reliability, uptime
2. bSame starting state plus same inputs gives byte-identical results — enabling replay from inputs alone, rollback that re-simulates correctly, and lockstep networking with bandwidth independent of world size
3. cFixed frame rate; smoothness, responsiveness, consistency
4. dSingle-threaded execution; debuggability, simplicity, portability

07why

Why is floating-point non-associativity fatal rather than merely imprecise?

1. aIt isn't; the error is negligible
2. bThe simulation feeds each frame's result into the next, so a one-ULP disagreement compounds — two machines differing in the last bit on frame 1 are visibly different by frame 400
3. cIt causes NaN propagation
4. dIt only matters for very large numbers

08why

What is the relationship between order-independence, parallelism and determinism?

1. aDeterminism requires abandoning parallelism
2. bOne property does both — if an entity's result depends only on its own data, processing order can't affect the outcome, so the work parallelizes safely and stays deterministic regardless of scheduling
3. cParallelism guarantees determinism when Burst is enabled
4. dThey are independent concerns

09why

NativeList.ParallelWriter passes every safety check. Why can it still ruin determinism?

1. aIt has a latent race the checker misses
2. bThread-safe and deterministic are different properties and the safety system only verifies the first — appended element order depends on thread timing, so anything downstream accumulating floats over that list varies per run, with no error anywhere
3. cIt isn't Burst-compatible
4. dIt allocates on the main thread

10why

Why must a fixed-step group loop to catch up rather than scale its delta to the frame time?

1. aSmaller steps are more numerically stable
2. bScaling makes step size a function of frame rate, so 30 fps and 60 fps machines compute different results — the exact variable-delta problem the fixed step eliminates. Determinism requires the step never varies, so the only free variable is step count
3. cThe job system can't handle large deltas
4. dLooping reduces cache pressure

11why

Explain the spiral of death and why the step cap's slow-motion behaviour is correct.

1. aIt's a bug; the cap is a workaround
2. bExpensive steps lengthen the frame, which accumulates more time, which demands more steps — positive feedback inherent to catch-up. The cap discards time so the game runs slow, which is the only option that keeps the simulation both responsive and reproducible; the alternatives are hanging or losing determinism
3. cThe spiral is caused by garbage collection and the cap avoids it
4. dSlow motion is a rendering artifact, not a simulation choice

12why

Presentation interpolates between simulated states. Which earlier design decision does that justify, and how?

1. aThe 16 KB chunk size, by bounding the interpolation set
2. bModule 6 storing LocalTransform as decomposed TRS with a quaternion rather than a matrix — presentation blends between discrete simulation ticks every frame, and blending matrices produces something that isn't a rotation
3. cThe Prefab tag, by hiding interpolated entities
4. dBlob immutability, by keeping interpolation targets stable

13how

A system that samples player input is placed in the fixed-step group. Predict the symptom.

1. aA compile error
2. bInput is never sampled in a frame with zero fixed steps and sampled three times in a frame with three — producing input that feels inconsistent under frame-rate variation, hard to diagnose because the code is correct and only its group is wrong
3. cA data race with the render thread
4. dNondeterministic simulation

14howmeasure

In the lab, how many distinct checksums did five runs of the parallel-accumulation version produce?

15why

Someone proposes adding a parallel sum over all entities to simulation code in a networked game. Give the full objection.

1. aParallel sums are slow
2. bCombination order across threads varies with completion order, and float addition isn't associative, so the result differs per run — which breaks rollback and lockstep silently, since the safety system reports nothing and the divergence appears hundreds of ticks later as unexplainable desync
3. cIt will cause a race condition the safety system will reject
4. dSums must be done at presentation time