6 exercises — reading comprehension and matching for entity/component/system concepts, archetypes, queries, and the cache-locality/parallelism benefits of data-oriented design.
0 / 6 completed
1 / 6
Read: "An entity is just an ID. Components hold data. Systems operate on all entities with a given component set." In Entity-Component-System (ECS) architecture, what is an entity?
In ECS, an entity is deliberately empty — it carries no data and no logic. It is a plain identifier that acts as a "join key" linking together whatever components happen to be associated with it. This is the opposite of traditional object-oriented GameObjects, where an object bundles both state and behaviour in one class.
Vocabulary: "Entity 42 has a `Position` component and a `Health` component" means the ID 42 is associated with rows in the `Position` and `Health` component storage — there is no "Entity" object holding pointers to them.
2 / 6
Which statement correctly describes an ECS "component"?
A component in ECS is pure data — typically a plain struct with fields and no methods. Separating data (components) from behaviour (systems) is the defining principle of ECS, and it is what enables data-oriented storage and parallel processing.
Example components: `Position { x: f32, y: f32 }`, `Velocity { dx: f32, dy: f32 }`, `Health { current: i32, max: i32 }`. None of these contain logic — a `MovementSystem` reads `Position` and `Velocity` together and writes the updated `Position` each tick.
3 / 6
Read: "This system queries for all entities with `Position` and `Velocity` components." What does "queries for" mean in this ECS context?
A query in ECS asks the framework to return the set of entities that have a specific combination of components, so a system can iterate over exactly the data it needs — nothing more. A `MovementSystem` querying `(Position, Velocity)` receives only entities that have both; an entity with just `Position` (e.g. a static wall) is skipped automatically.
This is analogous to a SQL SELECT ... WHERE in spirit (hence "query"), but it operates over in-memory component arrays each frame rather than a database — ECS frameworks are built for extremely high query throughput (millions of entities per frame in engines like Bevy or Unity DOTS).
4 / 6
Read: "Entities sharing the same component composition belong to the same archetype." What is an archetype?
An archetype groups all entities that share the exact same set of component types, storing their component data contiguously in memory (a technique called a "structure of arrays" layout). When a system queries `(Position, Velocity)`, the ECS scheduler can jump straight to the relevant archetype chunks and iterate over tightly packed arrays instead of scattered objects.
Adding or removing a component from an entity moves it to a different archetype (its composition changed), which is a relatively expensive operation in most ECS implementations — a common performance tip is "avoid frequent add/remove of components in a hot loop; prefer a boolean flag component instead."
5 / 6
Which of the following is a real-world ECS or ECS-inspired framework, useful vocabulary to recognise when comparing implementations across engines?
Bevy, Unity DOTS, and Flecs are all ECS implementations, but with different design choices worth knowing the vocabulary for:
• Bevy (Rust) — ECS is the core architecture of the entire engine; systems are plain Rust functions, and Bevy's "app" is built by registering systems into schedules. • Unity DOTS — an opt-in, high-performance alternative to Unity's traditional `MonoBehaviour`/GameObject model, using `Entity`, `IComponentData`, and `SystemBase`/`ISystem`, compiled with Burst for near-native performance. • Flecs — a standalone, engine-agnostic C/C++ ECS library that can be embedded in custom engines, with features like hierarchical relationships between entities.
Being able to say "this engine uses an archetype-based ECS" or "this system is scheduled to run in parallel with that system because they touch disjoint component sets" is core vocabulary across all three.
6 / 6
Which of these is a genuine advantage of ECS ("data-oriented design") over traditional object-oriented GameObjects, described in correct English terms?
The two headline advantages of ECS, phrased precisely:
1. Cache locality: because components of the same type are stored contiguously (rather than scattered across heap-allocated objects), iterating over thousands of `Position` components in a tight loop hits the CPU cache far more often than chasing pointers through a traditional object graph — this is the essence of "data-oriented design." 2. Parallel processing: because each system explicitly declares which component types it reads and writes, the scheduler can prove two systems don't touch overlapping data and run them on different threads automatically, without manual locking.
Neither advantage is automatic magic — they require the developer to design components and systems with these properties in mind (e.g. keeping components small and avoiding unnecessary read/write conflicts).
What does the "ECS Vocabulary — Game Engine Language Exercises" exercise cover?
Practise Entity-Component-System (ECS) vocabulary in English: entities, components, systems, queries, archetypes, and data-oriented design, with Bevy/DOTS/Flecs comparisons.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to use with no account, sign-up, or paywall.
How many questions are in "ECS Vocabulary — Game Engine Language Exercises"?
This exercise has 6 questions. Each one gives instant feedback with an explanation, so you can see exactly why an answer is right or wrong.
Do I need to create an account to save my progress?
No account is required. The progress bar and score are tracked in your browser for the current session -- the exercise is designed to be a quick, repeatable drill rather than something you resume later.
What happens if I get an answer wrong?
You'll see the correct answer highlighted immediately, along with a short explanation of why it's correct. Wrong answers aren't penalized beyond your score, and you can keep going through every question.
How is this exercise different from reading an article?
Articles explain vocabulary and concepts through prose, while exercises like this one are interactive drills -- multiple-choice questions -- that test and reinforce your recall of specific terms and phrasing.
Can I retry this exercise?
Yes -- use the "Try again" button on the results screen to reset your score and go through all the questions again from the start.
Where can I find more Game Engine Language exercises?
Browse the full Game Engine Language hub for related drills, or check the site-wide exercises index for other IT English topics.
Is this exercise suitable for beginners?
This exercise assumes basic familiarity with IT terminology. If a term feels unfamiliar, check the site Glossary for a plain-English definition before attempting the questions.
How often is new content like this published?
New exercises are added regularly across all categories, alongside new vocabulary sets and articles. Check back on the exercises hub to see what's new.