This list is provided as a guide for tools engineers of all skill levels looking for jobs in the game industry. It's meant as a guide to topics that should be pursued broadly in order to be well spoken in an interview. I doubt any hiring manager requires deep knowedge across every topic, but an ideal candidate would be somewhat knowledgable (aware of its existence if asked directly) with all topics here.

Each list of bullets increases in difficulty, so later bullets are more applicable to senior (or even director) level candidates.

Good luck.

@gorlak

Math

Numbers

Radix (2: binary, 10: decimal, 16: hexadecimal)

Alegbra

Polynomials
Conic sections

Linear Algebra

Matrices for representing systems of equations
The determinant and what it tells you about a matrix

Trigonometry:

All the trigonometric functions
How each trig function relates to coordinate components on the unit circle

ℝ3 and affine transformations:

Fundamental vector operations: addition, subtraction, dot product, cross product
Vectors that are "normalized," "orthogonal," and "ortho-normalized"
Basis vectors of a matrix
Row-major vs. column-major notation
The plane equation, and its related to the dot product
Affine transform composition: scale, rotation, translation
Affine transform concatenation: global/parent/object space
Affine transform inversion
Affine transform decomposition

Rotations

Euler angles, axis-angle, quaternion, rotation matrices
3-by-3 Rotation matrices (matrices, normal and non-normal, orthogonal and non-orthogonal)
How euler angles are short-hand for rotation matrices
How to intuit a rotation from a 3-by-3 ortho-normalized matrix
Euler angle static and rotating frame conventions

Graphics

Pipeline

Object, parent, global, camera, projection, viewport transforms
Point un-projection into rays, rect un-projection into frustums
Ray/frustum instersection vs. point, sphere, line, triangle
Clip space and screen-space primitive clipping

Rendering

Vertex buffers and common vertex attributes
Backface culling and winding order
Depth buffers, depth-test renderstate, depth prepass
Alpha values and blending functions
Sorting for rendering passes
Command buffers and immediate/deferred contexts
Examples of typical passes (as parts of a forward vs deferred frame)

Shaders

General graphics shader types and their args and results
Fixed function GPU hardware and how they speed up passes
How branches work, what they cost
Async compute

Computer Architecture

Numbers

Unsigned vs. signed, twos compliment
IEEE-754 floating point components
Floating point accuracy and large cardinality floating point numbers

ISA

Endianness
Pipelining
Instrution latency
Memory prefetch

Atomics

Increment, decrement, compare-exchange
Spin-locks and latency trade-offs

Cache

Typical cache sizes
The memory hierarchy and relative costs
Necessity/benefit of memory alignment
"Ways" and cache eviction policies

Operating Systems

Concepts

File descriptors, HANDLEs
Blocking vs. non-blocking I/O requests
The fundamental sync primitives and wait functions
Manual and automatic condition/event primitives
Syscall overhead
Memory protection and superuser instructions
Exceptions and interrupt service routines

Threads

Memory contention and the basic dangers of threads
OS-implemented mutex objects and the thread/process scheduler
Thread local storage

Sockets

TCP vs. UDP
Network order
Latency with select-polling vs. blocking waits vs. async

Virtual Memory

How virtual memory is related to physical memory, swap
How CPU hardware makes virtual memory performant

Modules

Shared objects vs. static libraries
Styles of "dynamic linking" on windows
Practicality of code unloading
Jump tables
Process loading and the dynamic loader
Pages inherently shared vs. non-shared across processes
Page protections, JIT

C Programming Language

Functions

Recursion, best practices
Inlining and optimization
Function arguments and CPU stack machine (push + jump)
Stack memory allocation and deallocation
C89 variable declaration rules
setjmp/longjmp

Strutures

Alignment and padding
Unions
Brace initialization

Arrays

Countof

Pointers

Pointer arithmetic
restrict and aliasing

Memory

alloca vs. malloc

C++ Programming Language

Objects

Implicit this
Overloading and overload resolution
Constructor and destructor (implications for this's virtuals, exceptions)

Virtuals

vtable: when is it set, how is it found, and what does it contain
vtable: what are the implications of multiple inheritance

Generics

Function templates, class templates, concerns about code bloat
Runtime type information (vs. reflection), type traits
Template meta-programming, constexpr

Managed Programming Languages

Garbage Collectors

Pro/con to reference counting
Mark/sweep
Implications for deadline-based programs

Destructors vs. Finalizers
IDisposable
Pinning

Development

Techniques

Instrumented profilers, hit counters, time accumulators
Obfuscated handle systems (vs. pointer)
Pointer-to-implementation/PIMPL benefits and costs
Delegates, multicast delegates and events
Retained mode vs. immediate mode graphical user interfaces
Event-loop programming w/ all nonblocking I/O routines
Type reflection/introspection for program automation
Program binding time (bind at compile time, link time, run time)
Out-of-schema (blind) data retention, version interop
Object-relational-mapping (and pitfalls with polymorphism)
Runtime compiled code

Debugging

Breakpoints
Conditional breakpoints
Hardware breakpoints
Tracepoints
Debugger implementation of breakpoints
Code with timeouts and debuggability

Determinism

Definition and the desire to achieve it
Typical pitfalls in C/C++

Concurrency

The difference between concurrency and parallelism
Job/task graph systems
Fibers and implications for stack, TLS risks

Revision Control

Merging

The three parts of a three way merge
Topics branches and good development practices
Knowing when to stash/shelve work in progress
Branching for every version vs. pipeline strategies

gorlak/tools-engineer-checklist.md