Advanced Kotlin Programming Online – 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

• By the end of this course, the learner will be able to:
• Apply advanced Kotlin generic programming and variance.
• Use inline functions and reified type parameters appropriately.
• Design reusable APIs using Kotlin’s type system.
• Use class delegation and delegated properties.
• Create asynchronous programs using suspending functions and coroutines.
• Apply structured-concurrency principles.
• Manage coroutine contexts, dispatchers and lifecycle.
• Handle coroutine cancellation and exceptions safely.
• Process asynchronous data streams using Kotlin Flow.
• Coordinate concurrent operations using channels.
• Create type-safe Kotlin domain-specific languages.
• Apply annotations and reflection responsibly.
• Design Kotlin libraries that work effectively with Java.
• Test asynchronous and concurrent Kotlin code.
• Analyse Kotlin/JVM performance and resource use.
• Document public Kotlin APIs with KDoc.
• Apply static analysis and automated code-quality checks.
• Package and distribute reusable Kotlin/JVM components.
• Build and document a production-style advanced Kotlin project.

Modules

1. 1

   Advanced Kotlin Type System

   Nullable and non-nullable type relationships.The Any type.The Unit type.The Nothing type.The Nothing? type.Smart casts.Smart-cast limitations.Type aliases.Function types with receivers.Definitely non-nullable types.Representing valid and invalid program states through types.
2. 2

   Advanced Generics

   Generic type relationships.Invariance.Declaration-site variance.Covariance with out.Contravariance with in.Use-site type projections.Star projections.Upper bounds.Multiple generic constraints.Generic type erasure.Designing reusable generic APIs.
3. 3

   Inline and Reified Functions

   Meaning of inline functions.Benefits and limitations of inlining.Using noinline.Using crossinline.Reified type parameters.Non-local returns.Function references.Functions with receivers.Functional API design.Readability and performance trade-offs.
4. 4

   Advanced Functional Programming

   Higher-order function design.Function composition.Pure functions.Immutability.Side effects.Closures.Partial application concepts.Functional error handling.Building reusable data-processing pipelines.Balancing functional and object-oriented approaches.
5. 5

   Class Delegation

   Review of delegation.Advanced class delegation.Replacing inheritance with delegation.Creating reusable delegated behaviours.Combining multiple delegated responsibilities.Testing delegated components.Delegation in library design.
6. 6

   Delegated Properties

   Standard property delegates.Lazy properties.Observable properties.Vetoable properties.Delegating to another property.Storing properties in maps.Creating custom property delegates.The getValue operator function.The setValue operator function.Delegate providers.Practical applications of delegated properties.
7. 7

   Coroutine Foundations

   Synchronous and asynchronous programming.Threads compared with coroutines.Suspending functions.Coroutine scopes.Coroutine builders.Using launch.Using async.Using await.Using coroutineScope.Structured concurrency.Designing asynchronous Kotlin applications.
8. 8

   Coroutine Context and Dispatchers

   Understanding coroutine context.Jobs and parent-child relationships.Coroutine dispatchers.Switching execution contexts.CPU-intensive operations.Input and output operations.Custom coroutine contexts.Debugging coroutine execution.Choosing appropriate dispatchers.
9. 9

   Coroutine Cancellation and Lifecycle

   Coroutine lifecycle.Cooperative cancellation.Cancelling coroutines.Cancellation checks.Timeouts.Cleaning up resources.Non-cancellable cleanup.Supervisor jobs.Supervisor scopes.Preventing abandoned background operations.
10. 10

    Coroutine Exception Handling

    Exception propagation.Exceptions in launch.Exceptions in async.Coroutine exception handlers.Cancellation exceptions.Aggregating multiple failures.Supervisor-based error isolation.Designing reliable asynchronous error handling.Testing coroutine failures.
11. 11

    Shared State and Concurrency Safety

    Shared mutable state.Race conditions.Synchronisation.Mutexes.Atomic operations.Thread confinement.Immutability in concurrent programs.Protecting shared resources.Designing concurrency-safe components.Identifying and preventing data corruption.
12. 12

    Kotlin Flow Fundamentals

    Meaning of asynchronous streams.Cold streams.Creating flows.Emitting flow values.Collecting flow values.Flow cancellation.Transforming flows.Filtering flows.Terminal flow operations.Building asynchronous processing pipelines.
13. 13

    Advanced Flow Operations

    Combining flows.Buffering.Conflation.Flattening flows.Flow context.Flow exception handling.Flow completion.SharedFlow.StateFlow.Hot and cold stream differences.Testing Flow-based programs.
14. 14

    Kotlin Channels

    Meaning and purpose of channels.Sending and receiving values.Buffered channels.Unbuffered channels.Closing channels.Channel cancellation.Producer-consumer patterns.Fan-out.Fan-in.Channel pipelines.Selecting between channel operations.Choosing between channels and Flow.
15. 15

    Kotlin Domain-Specific Languages

    Meaning of a domain-specific language.Function literals with receivers.Builder patterns.Nested builder structures.Operator overloading.Infix functions.The invoke convention.Type-safe builders.DSL markers.Restricting receiver scope.Designing readable Kotlin DSLs.Testing domain-specific languages.
16. 16

    Annotations

    Declaring custom annotations.Annotation parameters.Annotation targets.Annotation retention.Reading annotation information.Applying annotations to classesproperties and functions.Annotation use cases.Annotation-driven validation concepts.Designing maintainable annotation-based features.
17. 17

    Kotlin Reflection

    Class references.Callable references.Property references.Function inspection.Constructor inspection.Reading annotations at runtime.Kotlin reflection on the JVM.Java reflection interoperability.Reflection-based mapping and validation.Performance and maintenance considerations.Situations where reflection should be avoided.
18. 18

    Advanced Capstone Project

    Suggested projects include:Concurrent transaction-processing engine.Asynchronous tourism inventory aggregator.SACCO transaction-validation library.Kotlin data-import and transformation pipeline.Concurrent school-results processing service.Reusable financial-calculation library.Agricultural market-data processor.Java-compatible Kotlin business-rules library.Asynchronous command-line reporting system.Transport scheduling and data-processing engine.Multi-source inventory synchronisation system.