CAP theorem
~11 minTwo data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
Trains you for game developer interviews, from coding rounds to engine and graphics deep dives. Spans game math and physics, C++ and engine languages, real-time rendering, and game AI.
8522 of 8522 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 8522 new. 0 cut, outside your plan.
Two data centres hold the same data. The link between them breaks. Each must now answer from its own copy, or refuse. CAP is the proof that there is no third way.
Game programming interviews divide early by specialty. After a recruiter call there is usually a timed coding test, often in C++, or a take-home that asks for a small working system rather than a puzzle. Then the rounds split: gameplay candidates are asked about vector math, physics and the studio's engine; engine and graphics candidates about memory, threads and the rendering pipeline. Most loops also ask about something you built and end on a behavioral conversation.
The math questions are small and exact. Given a character's facing and an enemy's position, decide with one dot product whether the enemy is in front. Explain why a fast bullet passes through a thin wall and what a swept test changes, why normals are transformed by the inverse transpose of the model matrix, why interpolated Euler angles wobble where a quaternion slerp does not, and why physics steps at a fixed rate while the frame rate floats.
Seniority shows in the frame budget. A weaker answer is correct on paper; a stronger one prices it: a virtual call per entity per frame, objects scattered across the heap where a packed array would stay in cache, an allocation in a C# update loop that the garbage collector later repays as a frame-time spike. Senior candidates are expected to say how a profiler would show the cost before they say how to remove it.
Interviews for game roles keep the general engineering foundations for concrete reasons: memory management and concurrency are the theory under the later questions about allocators and worker threads, and the coding module comes early because the timed test is usually the first technical gate.
Math comes before any language, because physics, rendering and game AI are all written in it. Game mathematics builds from vectors through matrices and quaternions to intersection tests and floating-point robustness; physics and collision then spends that vocabulary on timesteps, finding contacts and resolving them.
The language module is really a choice of engine. C++ carries Unreal and most engine code, C# carries Unity, and few candidates need every language in it. A short tooling stretch follows, where Git LFS handles the large binary assets a plain repository struggles with and CMake builds the C++.
The engine stretch teaches how an engine is built rather than any one product: the game loop, entity-component systems, job systems, frame budgets. That model travels to whichever engine the studio uses, where Unity's components, Unreal's actors and Godot's node tree stop being separate vocabularies: each is one engine's way to organize entities and the loop that updates them. Graphics follows, and it too stays above any one API: real-time rendering runs from the pipeline through lighting and shadows to deferred shading, and takes in how work is submitted to the GPU and how a shader program is shaped, so a Vulkan or DirectX question can be answered from what the frame needs rather than from which call to make.
Game AI comes late because it draws on almost everything before it: graph search from the coding module for pathfinding, geometry and steering math for movement. The plan closes with testing and quality and then leaves the code entirely, for behavioral questions and the stages of the hiring process itself.
Decide first which programmer the posting wants, because gameplay and engine roles share the opening stretches and then part. Gameplay candidates should make math, physics and game AI solid and go deep on the one engine the studio ships with, which they learn alongside this plan rather than from it. Engine and graphics candidates live in C++, engine architecture and rendering, and should be able to explain why an explicit API leaves synchronization to the application. Students and juniors are usually tested hardest on algorithms, C++ memory and vector math, whatever the specialty. Short on time, let the page shrink the plan first: drop everything below must know from importance, hold level to the band the posting names, and leave study order where it opens, on by frequency. Then trim by hand what no control knows about your stack: a Unity candidate can set Rust and CMake aside, an Unreal candidate C# and Rust. With months in hand, let study order follow the plan by topics, because rendering leans on the math module and pathfinding on the coding one. Either way, have a playable build ready to discuss; the questions about it go quickly to why it holds its frame rate. The plan stays on the client side of a game. It has no module on multiplayer networking: replicating state, compensating for lag, running the servers an online game depends on. The [Server-Side Game Developer roadmap](/roadmaps/server-side-game-developer) takes up that half.
Decide first which programmer the posting wants, because gameplay and engine roles share the opening stretches and then part. Gameplay candidates should make math, physics and game AI solid and go deep on the one engine the studio ships with, which they learn alongside this plan rather than from it. Engine and graphics candidates live in C++, engine architecture and rendering, and should be able to explain why an explicit API leaves synchronization to the application. Students and juniors are usually tested hardest on algorithms, C++ memory and vector math, whatever the specialty.
Short on time, let the page shrink the plan first: drop everything below must know from importance, hold level to the band the posting names, and leave study order where it opens, on by frequency. Then trim by hand what no control knows about your stack: a Unity candidate can set Rust and CMake aside, an Unreal candidate C# and Rust. With months in hand, let study order follow the plan by topics, because rendering leans on the math module and pathfinding on the coding one. Either way, have a playable build ready to discuss; the questions about it go quickly to why it holds its frame rate.
The plan stays on the client side of a game. It has no module on multiplayer networking: replicating state, compensating for lag, running the servers an online game depends on. The Server-Side Game Developer roadmap takes up that half.