Game Development Programming for Games Syllabus

Programming for Games syllabus — full chapter and topic list

Expand any chapter to see its topics and sub-topics. This is the whole examinable outline for Programming for Games in Game Development, not a summary of it.

1. 1

   Programming Languages

   4 topics

   • C++
   • C#
   • JavaScript
   • Python
2. 2

   Game Engine Scripting

   3 topics

   • Unity Scripting with C#
   • Unreal Engine Scripting with C++/Blueprints
   • Godot Scripting with GDScript
3. 3

   Algorithms and Data Structures

   3 topics

   • Pathfinding Algorithms
   • Sorting and Searching Algorithms
   • Data Structures (Arrays, Lists, Trees, Graphs)

Programming for Games flashcards for Game Development

24 of 50 cards from the Programming for Games deck — real questions with worked answers.

1. In C++, what is the difference between passing a parameter by value and passing it by reference?

   Pass by value copies the argument into a new local variable, so changes inside the function do not affect the original. Pass by reference (using `&`, e.g. `void f(int& x)`) gives the function an alias to the original variable, so modifications affect the caller's value and no copy is made.

2. What is a pointer in C++, and which operators are used to take an address and to dereference it?

   A pointer is a variable that stores the memory address of another object. The address-of operator `&` obtains an object's address (`int* p = &x;`), and the dereference operator `*` accesses the value at that address (`*p`).

3. In C++, what is RAII (Resource Acquisition Is Initialization)?

   RAII is a pattern where resource lifetime is tied to object lifetime: a resource (memory, file, lock) is acquired in a constructor and released in the destructor. When the object goes out of scope, the destructor automatically frees the resource, preventing leaks.

4. What is the difference between the stack and the heap in C++ memory management?

   The stack stores local variables with automatic storage duration; allocation/deallocation is fast and automatic via scope. The heap (free store) is used for dynamic allocation via `new`/`delete` (or smart pointers); it is manually managed, larger, and slower to allocate.

5. In C++, what do the smart pointers `std::unique_ptr` and `std::shared_ptr` represent?

   `std::unique_ptr` models exclusive ownership of a heap object (cannot be copied, only moved). `std::shared_ptr` models shared ownership via reference counting; the object is destroyed when the last `shared_ptr` referring to it is destroyed.

6. What are the four pillars of Object-Oriented Programming, common to C++, C#, and other OOP languages?

   Encapsulation (bundling data with methods and hiding internals), Abstraction (exposing only essential features), Inheritance (deriving new classes from existing ones), and Polymorphism (the same interface behaving differently across types).

7. In C#, what is the difference between a value type and a reference type?

   Value types (structs, enums, primitives like `int`) store their data directly and are copied on assignment, typically living on the stack. Reference types (classes, arrays, strings, delegates) store a reference to data on the managed heap; assignment copies the reference, not the object.

8. What is garbage collection in C#, and how does it differ from C++ memory management?

   In C#, the .NET Garbage Collector automatically reclaims memory of objects no longer reachable, so the programmer generally does not free memory manually. In C++ there is no built-in GC; memory is managed manually with `new`/`delete` or via RAII/smart pointers.

9. In C#, what is the purpose of the `IEnumerable<T>` interface and the `foreach` loop?

   `IEnumerable<T>` represents a sequence that can be iterated. Implementing it (via `GetEnumerator()`) lets a type be used in a `foreach` loop, which sequentially retrieves each element without exposing the underlying collection structure.

10. What is the difference between `==` and `===` in JavaScript?

    `==` is the loose equality operator: it performs type coercion before comparing (e.g. `1 == '1'` is true). `===` is strict equality: it compares both value and type without coercion (`1 === '1'` is false). `===` is generally preferred.

11. In JavaScript, what is a closure?

    A closure is a function together with the lexical environment in which it was declared. It allows an inner function to continue accessing variables from its enclosing (outer) function's scope even after that outer function has returned.

12. What is the difference between `let`, `const`, and `var` in JavaScript?

    `var` is function-scoped and hoisted. `let` is block-scoped and can be reassigned. `const` is block-scoped and cannot be reassigned (though the contents of an object/array it references may still be mutated).

13. In JavaScript, what is the event loop and why is it important for game/UI loops?

    The event loop is the mechanism that lets single-threaded JavaScript handle asynchronous operations: it repeatedly takes callbacks from the task/microtask queues and runs them when the call stack is empty. It enables non-blocking I/O and drives frame-based updates (e.g. via `requestAnimationFrame`).

14. In Python, what is the difference between a list and a tuple?

    A list is mutable and defined with square brackets `[]`, so its elements can be changed, added, or removed. A tuple is immutable and defined with parentheses `()`; once created its contents cannot be modified, which makes tuples hashable and usable as dictionary keys.

15. What is a Python dictionary, and what is the average time complexity of a key lookup?

    A dictionary is a mutable collection of key-value pairs implemented as a hash table. Key lookup, insertion, and deletion run in $O(1)$ average time, degrading to $O(n)$ in the worst case of many hash collisions.

16. In Python, what is a list comprehension? Give its general syntax.

    A list comprehension is a concise way to build a list from an iterable. General form: `[expression for item in iterable if condition]`, e.g. `[x*x for x in range(10) if x % 2 == 0]` produces the squares of even numbers 0-8.

17. What is the Global Interpreter Lock (GIL) in CPython?

    The GIL is a mutex that allows only one thread to execute Python bytecode at a time in the CPython interpreter. It simplifies memory management but prevents true parallel execution of CPU-bound threads; parallelism is instead achieved with multiprocessing.

18. In Unity, what is a MonoBehaviour and how is a script attached to game objects?

    `MonoBehaviour` is the base class every Unity C# script component derives from. A script deriving from it can be attached as a component to a GameObject, giving that object custom behavior and access to Unity's event callbacks.

19. In Unity scripting, what is the difference between the `Start()`, `Update()`, and `FixedUpdate()` methods?

    `Start()` runs once before the first frame, after `Awake()`, for initialization. `Update()` runs once per rendered frame (frame-rate dependent), used for most game logic. `FixedUpdate()` runs on a fixed timestep independent of frame rate and is used for physics calculations.

20. In Unity, why is `Time.deltaTime` used when moving objects in `Update()`?

    `Time.deltaTime` is the time in seconds since the last frame. Multiplying movement or rotation by it makes motion frame-rate independent, so an object moves at a consistent real-world speed regardless of how fast or slow frames are rendered.

21. In Unity, how do you access another component attached to the same GameObject from a script?

    Use `GetComponent<T>()`, e.g. `Rigidbody rb = GetComponent<Rigidbody>();`. It returns a reference to the component of type `T` on the same GameObject (or `null` if none exists), letting you read and modify its properties.

22. In Unreal Engine, what is the difference between C++ and Blueprints as scripting approaches?

    C++ is a text-based, compiled language offering maximum performance and low-level control. Blueprints are a visual node-based scripting system, faster to prototype and accessible to non-programmers. They interoperate: C++ classes and functions can be exposed to Blueprints via macros like `UFUNCTION(BlueprintCallable)`.

23. In Unreal Engine C++, what is the purpose of the `UPROPERTY()` and `UFUNCTION()` macros?

    They expose C++ members to Unreal's reflection system. `UPROPERTY()` exposes a variable to the editor, Blueprints, serialization, and garbage collection. `UFUNCTION()` exposes a function so it can be called from Blueprints, bound to events, or replicated over the network.

24. In Unreal Engine, what is the class hierarchy relationship between `UObject`, `AActor`, and `APawn`?

    `UObject` is the base class for all managed objects. `AActor` derives from `UObject` and represents objects that can be placed/spawned in a level. `APawn` derives from `AActor` and represents an actor that can be possessed and controlled by a player or AI controller.

See more Programming for Games flashcards →

Planning Programming for Games for Game Development

Programming for Games (Game Development) FAQ