Advanced Rust Systems Programming Course in Uganda & Africa

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 Rust programming course, the learner will be able to:
• Design expressive APIs using advanced traits, associated types, newtypes, marker types, and type-state patterns.
• Reason about memory layout, alignment, drop behaviour, variance, and ownership at low-level boundaries.
• Explain pinning, self-referential constraints, futures, and the mechanics behind async Rust.
• Apply atomics and memory ordering carefully and justify when a lock-based design is safer.
• Create declarative macros and understand the architecture of procedural macros.
• Identify the obligations introduced by unsafe Rust, raw pointers, unsafe traits, and foreign-function interfaces.
• Define, isolate, document, test, and review safety invariants around minimal unsafe code.
• Benchmark, profile, and optimise Rust programs using evidence rather than guesswork.
• Structure production-quality crates with workspaces, features, documentation, semantic versioning, and release profiles.
• Deliver a tested, documented, performance-aware systems utility or reusable Rust library.

Modules

1. 1

   Advanced Traits and Type-Driven Design

   Associated types and generic associated typesFully qualified syntaxSupertraits and trait-object designNewtype and marker-type patternsPhantom types and compile-time stateType-state APIs that prevent invalid operationsObject safety and dynamic versus static dispatch
2. 2

   Advanced Ownership, Memory Layout, and Drop Semantics

   Layout, alignment, padding, and representationDrop order and deterministic resource managementVariance and subtyping intuition`PhantomData` and ownership signallingLeaking, forgetting, and double-drop risksBuilding and reviewing custom resource-owning types
3. 3

   Pinning, Futures, and Async Internals

   Why self-referential values are difficult`Pin` and `Unpin`The `Future` trait and pollingWakers and cooperative progressState-machine intuition for `async` and `.await`Cancellation safety and resource cleanupDesigning async-aware types without an application framework
4. 4

   Advanced Concurrency and Atomics

   Thread-safety invariantsAtomic types and compare-and-exchange operationsMemory ordering: relaxed, acquire, release, and sequential consistencyLock-based versus lock-free trade-offsFalse sharing and contentionScoped threads and data parallelism conceptsTesting and reviewing concurrent algorithms
5. 5

   Declarative and Procedural Macros

   Repetition and matching with `macro_rules!`Macro hygiene and useful diagnosticsDesigning small domain-specific syntaxProcedural-macro architectureToken streams, parsing, and code generationDerive, attribute-like, and function-like procedural macrosTesting generated code and compile failures
6. 6

   Unsafe Rust, Raw Pointers, and FFI

   The unsafe superpowers and their obligationsRaw pointers and pointer operationsUnsafe functions and unsafe traitsSafe abstractions over unsafe internalsSafety comments, invariants, and audit boundariesForeign-function interface fundamentals and C-compatible typesUsing Miri and targeted tests where supported
7. 7

   Benchmarking, Profiling, and Optimisation

   Debug versus release behaviourBuilding trustworthy benchmarksPreventing misleading measurementsCPU, allocation, and binary-size profilingData layout, allocation, cloning, and cache behaviourZero-cost abstractions and monomorphisation trade-offsOptimising only after measuring
8. 8

   Production Crate Design and Advanced Capstone

   Workspace architecture and crate boundariesFeature flags and conditional compilationPublic API documentation and examplesSemantic versioning and compatibilityRelease profiles, lint policy, and dependency reviewBuild a performance-aware systems utility or reusable libraryDocument safety invariants and architectural decisionsAdd tests, benchmarks, profiling evidence, and release documentation