Lesson 1 · Professional programming culture
7 Rules
Use seven rules to distinguish code writing from professional programming: performance, correctness, evaluation, reuse, value, mentoring and enjoyment.
Masters Programmes
Masters Software Engineering
A Masters-level programming and software engineering course built one lesson at a time around professional judgement, correctness, performance, collaboration and reflective practice.
Lessons
Lesson 2 · State, naming and correctness
Understanding Variables
Treat variables as named state with scope, lifetime, invariants and failure modes.
Lesson 3 · State, lifetime and scope
The Lifecycle of a Variable
Understand how variables come into existence, receive values, leave scope and become invalid, then use that lifecycle to prevent common C++ errors.
Lesson 4 · Abstraction, reuse and interface design
Functions in C++
Design C++ functions as small, named units of work with clear inputs, outputs, ownership and performance expectations.
Lesson 5 · Program entry, arguments and exit status
The main Function in C++
Understand `main` as the executable entry point: where program control begins, arguments arrive, and exit status is returned to the operating system.
Lesson 6 · Function signatures, calls and substitution
Calling Functions and Parameter Lists
Call C++ functions by constructing parameter lists that match the required types, then reason about overloads, conversions and nested calls.
Lesson 7 · Translation units, declarations and build hygiene
Header Files, Includes and the Preprocessor in C++
Use headers and includes to share declarations cleanly across C++ translation units without causing duplicate definitions, cycles or global pollution.
Lesson 8 · Scope, translation units and linker-visible names
Namespaces and Name Conflicts
Use C++ namespaces to prevent name conflicts across blocks, files and translation units, then diagnose compile-time and link-time collisions.
Lesson 9 · Runtime boundaries, standard library I/O and systems mental models
"Hello, world": Why the Simplest C++ Program Is Not Simple
Use the familiar `Hello, world` program to expose the hidden machinery behind C++ I/O, runtime startup, buffering and operating-system interaction.
Lesson 10 · Iteration structure, loop correctness and data traversal
Loops, Control Variables and Iteration
Choose the right loop form, keep control variables disciplined, and reason about counted, range-based and sentinel-controlled iteration.
Lesson 11 · Condition-driven loops, sentinels and termination reasoning
While and Do-While Loops: Non-Deterministic Iteration
Use `while` and `do-while` loops when the iteration count is not known in advance, and reason carefully about state change and termination.
Lesson 12 · Conditional jumps, trace growth and branch reduction
If Statements, Determinism and Safer Control Flow
Use `if` statements deliberately, understand the execution paths they create and prefer clearer deterministic designs where possible.
Lesson 13 · Expression-level choice, substitution and readable value selection
The Conditional Operator `?:` in C++
Use the conditional operator deliberately when a branch chooses between values, while avoiding unreadable nesting and hidden side effects.
Lesson 14 · Pointers, addresses and low-level state
Direct Memory Manipulation and Pointers in C++
Understand raw pointers as direct access to memory addresses, then use that understanding to avoid dangling, invalid and unsafe pointer behaviour.
Lesson 15 · Stack, heap, pointer lifetime and ownership discipline
Memory Ownership, Pointers and RAII in C++
Reason about stack and heap lifetimes, avoid dangling pointers and leaks, and prefer RAII ownership over manual `new`/`delete`.