Advanced C++ Course Uganda – Performance and Concurrency

Course outline and learning expectations

This is a tutor-led course. The outline shows what your tutor will cover; teaching materials and examinations are provided directly to enrolled students.

What you will learn

• By the end of this advanced C++ programming course, the learner will be able to:
• Reason precisely about value categories, copy/move operations, lifetime and ownership.
• Apply the rule of zero and implement custom resource types only when necessary.
• Design type-safe generic libraries using templates, concepts and compile-time evaluation.
• Use ranges and modern standard-library facilities to express efficient data processing.
• Build correct concurrent programs with threads, tasks, mutexes and condition variables.
• Explain data races, deadlocks, atomic operations and the purpose of the C++ memory model.
• Profile CPU time, allocations and memory behaviour before optimising.
• Improve performance using cache-aware data layout, fewer allocations and appropriate algorithms.
• Harden C++ code with sanitizers, static analysis, fuzz-friendly design and warning-clean builds.
• Architect, benchmark, test and document a performance-sensitive C++20 application.

Modules

1. 1

   Lifetime, Value Categories and Move Semantics

   Object lifetime and storage duration in depthlvalues, rvalues and referencesCopy and move construction/assignmentRule of zero, rule of five and strong invariants`std::move`, perfect forwarding and common misuseCopy elision and return-value optimisation**Lab:** Diagnose unnecessary copies in a transaction-processing pipeline
2. 2

   Advanced RAII and API Design

   Resource-owning types and custom deletersOwnership in public interfacesViews, spans and non-owning accessException-safety guaranteesType-safe domain modellingStable, minimal and testable library interfaces**Lab:** Design a safe binary-file or device-resource wrapper
3. 3

   Templates, Concepts and Compile-Time Programming

   Variadic templates and parameter packsConcepts and constrained overloads`constexpr`, `consteval` and compile-time validationTraits and type transformationsClear diagnostics and controlling template complexityWhen runtime polymorphism is the better design**Lab:** Generic, constrained statistics or units library
4. 4

   Modern Data Processing and Performance Foundations

   Advanced algorithms, ranges and viewsCustom iterators only when neededAllocation behaviour and allocator awarenessContiguous data, locality and cache effectsData-oriented design versus object-heavy designBenchmark design and avoiding misleading measurements**Lab:** Benchmark two representations of market or telemetry data
5. 5

   Concurrency Fundamentals

   Processes, threads, tasks and asynchronous work`std::jthread`, cooperative cancellation and task lifetimeMutexes, scoped locks and condition variablesShared state, contention and reducing critical sectionsDeadlock causes and preventionProducer–consumer design**Lab:** Concurrent sensor-telemetry or transaction-batch processor
6. 6

   Atomics and the C++ Memory Model

   Data races and happens-before reasoningAtomic operations and atomic typesMemory ordering at a practical, safety-first levelLock-free versus lock-based trade-offsFalse sharing and contentionThreadSanitizer and repeatable concurrency tests**Lab:** Correct a racy counter/queue and compare safe designs
7. 7

   Profiling, Optimisation and Code Hardening

   Establishing performance requirements and baselinesCPU, memory and allocation profilingAlgorithmic improvements before micro-optimisationCompiler optimisation levels and debug/release differencesSanitizers, static analysis and fuzz-friendly input boundariesUndefined behaviour and secure input handling**Lab:** Profile and harden an intentionally inefficient data processor
8. 8

   Capstone: High-Performance African Systems Project

   Build one project: concurrent payment-batch validator,transport-route engine, telemetry aggregator or engineering-data processorDefine throughput, latency, memory and correctness targetsApply safe ownership, generic components and controlled concurrencyAdd unit, integration and concurrency testsBenchmark, profile and document evidence-based improvementsPresent architectural decisions, limitations and next steps