Instantly share code, notes, and snippets.

Embed
What would you like to do?
Tools Engineer Checklist

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

C#

  • 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
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment