Intermediate Rust Programming Course in East Africa: Traits, Lifetimes & 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 intermediate Rust programming course, the learner will be able to:
• Refactor Rust code into idiomatic, reusable, and maintainable components.
• Design generic functions and types with traits, trait bounds, associated types, and where clauses.
• Apply explicit lifetime annotations when Rust cannot infer reference relationships.
• Use closures, iterators, adapters, and consuming operations effectively.
• Choose and apply `Box`, `Rc`, `Arc`, `RefCell`, and `Mutex` based on ownership and concurrency needs.
• Design useful error types and create clear error-propagation boundaries.
• Write safe multithreaded programs with threads, channels, shared state, `Send`, and `Sync`.
• Explain futures and use Rust's `async` and `.await` language syntax at a foundational level.
• Manage multi-package code with Cargo workspaces, dependencies, and feature flags.
• Test public behaviour and build a concurrent, reusable Rust command-line application.

Modules

1. 1

   Idiomatic Ownership and API Design

   Reviewing moves, copies, borrowing, and slicesChoosing owned values or referencesBorrowing fields and returning references safelyAvoiding unnecessary cloningDesigning clear function signaturesRefactoring beginner code into idiomatic Rust
2. 2

   Generics, Traits, and Lifetimes

   Generic functions, structs, enums, and methodsTrait definitions and implementationsTrait bounds, multiple bounds, and `where` clausesReturning types that implement traitsAssociated types and default methodsLifetime syntax, elision rules, and lifetime bounds
3. 3

   Closures and Iterators

   Closure capture by borrowing, mutable borrowing, and ownership`Fn`, `FnMut`, and `FnOnce`Iterator lazinessIterator adapters such as `map`, `filter`, and `filter_map`Consumers such as `collect`, `fold`, and `sum`Building a custom iteratorComparing iterator pipelines with explicit loops
4. 4

   Smart Pointers and Interior Mutability

   Heap allocation with `Box<T>`Shared ownership with `Rc<T>` and `Arc<T>`Interior mutability with `RefCell<T>`Shared mutable state with `Mutex<T>`Deref and Drop behaviourReference cycles and `Weak<T>`Selecting the correct ownership tool
5. 5

   Robust Error Handling and Testing

   Designing domain-specific error enumsConverting and propagating errorsAdding context without hiding the root causeTesting success, failure, and edge casesIntegration tests and test organisationDocumentation testsTestable program architecture
6. 6

   Safe Concurrency

   Creating and joining threadsMoving values into threadsMessage passing with channelsShared state with `Arc<Mutex<T>>`Understanding `Send` and `Sync`Avoiding deadlocks and reducing lock scopeDesigning deterministic concurrency tests
7. 7

   Async Rust Language Foundations and Cargo Workspaces

   Futures as values representing later computation`async fn`, async blocks, and `.await`Why async Rust requires an executorOwnership and borrowing across await pointsWhen threads or async are appropriateCargo workspaces and shared project structureDependency features and conditional compilation
8. 8

   Intermediate Rust Capstone

   Build a concurrent file indexer, log analyser, or transaction-validation toolCreate reusable generic components with traitsProcess multiple inputs safelyDesign structured errorsUse channels or shared state deliberatelyOrganise binary and library crates in a workspaceAdd unit, integration, and documentation testsRun formatting and lint checks