Checkpoint — systems, ordering, command buffers

01why

Why does a system hold no per-entity state, with all entity state living in components instead?

1. aTo reduce the number of classes in the codebase
2. bSo data can be laid out contiguously for the cache and vectorization while behaviour sweeps those arrays — and so a stateless transform is safe to run in parallel across chunks
3. cBecause C# structs can't hold fields
4. dIt's a convention with no performance consequence

02what

A system's OnUpdate is called how often, and what does it do inside that call?

1. aOnce per entity per frame; it processes that one entity
2. bOnce per frame; inside, it iterates all entities matching its query in a tight loop
3. cOnce at startup; it registers callbacks for each entity
4. dOnce per chunk; the runtime calls it per chunk automatically

03why

You choose SystemBase over ISystem to conveniently capture a managed object in your update loop. What's the hidden cost?

1. aSystemBase runs on a background thread and may race
2. bSystemBase is a managed class and can't be Burst-compiled as a whole, so your per-frame update opts out of native compilation and the fast path
3. cSystemBase can only process one entity per frame
4. dThere is no cost; the two are equivalent

04why

Why is system execution order declared with UpdateBefore/UpdateAfter attributes rather than inferred from file order or creation order?

1. aAttributes are easier to type than reordering files
2. bOrder encodes real data dependencies (B reads what A writes); tying it to incidental details like filenames would couple correctness to irrelevant things and break on a rename
3. cThe compiler can't read file order
4. dIt's inferred from creation order; the attributes are optional decoration

05why

A structural change cannot happen during query iteration. What is the fundamental reason?

1. aIt would be slow
2. bIt relocates entity data and can move the entities being iterated, invalidating the pointers the loop is streaming through — and in parallel, pointers other threads are reading right now
3. cUnity disables the EntityManager during OnUpdate as a policy
4. dIteration locks the chunk against all access

06how

Why does batching 5,000 destroys into one ECB played at a single sync point beat 5,000 immediate structural changes?

1. aThe ECB compresses the commands to use less memory
2. bA sync point is a hard barrier that drains outstanding jobs; batching pays that barrier once instead of 5,000 times
3. cImmediate structural changes aren't allowed at all
4. dThe ECB runs the destroys on a separate thread for free

07why

You record structural changes from a parallel job using a constant sortKey of 0 for every command. What breaks?

1. aNothing; sortKey is optional
2. bDeterminism — threads finish in unpredictable order, so with no distinct ordering key, playback order varies between runs and the simulation can diverge (fatal for networking/replays)
3. cThe commands are silently dropped
4. dPlayback becomes faster but uses more memory