Advanced Swift Programming Course in Uganda & East 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

• Design expressive generic APIs with constraints, conditional conformances and specialised behaviour.
• Use associated types, opaque types and existentials while understanding their trade-offs.
• Apply type erasure and advanced language features only when they improve an API.
• Build structured asynchronous workflows with async/await, tasks and task groups.
• Protect shared state with actors, isolation and Sendable under Swift 6 data-race checks.
• Diagnose reference cycles and reason about ARC, closure captures and memory safety.
• Measure and improve performance through algorithm choice, allocation awareness and value semantics.
• Publish a documented, tested and performance-checked Swift package with a stable public API.

Modules

1. 1

   Advanced Generics and Conditional Conformance

   Model algorithms with generic parameters and multiple constraintsUse where clauses, same-type requirements and conditional conformanceUnderstand generic specialisation and its design implicationsBalance reusable abstractions against compile-time and API complexity
2. 2

   Associated Types, Existentials and Opaque Types

   Design protocols with associated types and Self requirementsUse any for existential values and some for opaque return typesUnderstand dynamic dispatch, static dispatch and abstraction costsChoose concrete, generic, opaque or existential interfaces deliberately
3. 3

   Type Erasure and Expressive API Design

   Implement type-erased wrappers when heterogeneous storage is necessaryUse key paths, property wrappers and dynamic features responsiblyDesign fluent, discoverable APIs using Swift naming guidelinesProtect source compatibility and minimise public surface area
4. 4

   Structured Concurrency with async/await

   Model asynchronous functions and suspension pointsCreate child tasks and use async letProcess dynamic workloads with throwing and non-throwing task groupsHandle cancellation, priorities and error propagation
5. 5

   Actors, Isolation and Swift 6 Data-Race Safety

   Protect mutable state with actorsUnderstand actor isolation, global actors and nonisolated membersApply Sendable and safe transfer of values across isolation boundariesResolve Swift 6 concurrency diagnostics without unsafe shortcuts
6. 6

   ARC, Closures and Memory Behaviour

   Trace strong, weak and unowned references under ARCBreak reference cycles in object graphs and escaping closuresUnderstand value semantics, copy-on-write and mutation costsUse unsafe and unmanaged facilities only at explicit, reviewed boundaries
7. 7

   Performance, Testing and Diagnostics

   Select appropriate algorithms and data structures before micro-optimisingCompare debug and release behaviour and measure representative workloadsUse tests, sanitiser checks and targeted diagnosticsReduce allocations, unnecessary copying and contention based on evidence
8. 8

   Package Architecture and Advanced Capstone

   Separate public APIs, internal implementation and executable clientsDocument contracts, concurrency guarantees and error behaviourApply semantic versioning principles and package release hygieneComplete cross-platform tests, performance checks and a technical review