Kotlin Multiplatform Course

Lesson 1 • Understanding the Gradle Build System

Explains how Gradle orchestrates multiplatform builds and manages dependencies. Connects build configuration knowledge to every subsequent coding task in the course.

Lesson 2 • Creating Your First KMP Project

Walks through project creation using the KMP project wizard and examines the generated structure. Students gain familiarity with module layout before writing shared logic.

Lesson 3 • Setting Up the Development Environment

Guides installation of required tools including Android Studio, Xcode, and the Kotlin Multiplatform plugin. Ensures every student has a functional workspace before writing code.

Lesson 1 • Object-Oriented Patterns in Kotlin

Examines classes, interfaces, inheritance, and data classes used extensively in shared modules. These patterns form the structural backbone of shared business logic.

Lesson 2 • Kotlin Extensions and Delegation

Teaches extension functions, extension properties, and property delegation patterns. These tools reduce boilerplate in shared modules and improve cross-platform API design.

Lesson 3 • Functional Programming Features

Introduces lambdas, higher-order functions, and collection operations critical for concise shared code. Students apply these features to transform and filter shared data models.

Lesson 4 • Core Kotlin Syntax Review

Covers variables, functions, control flow, and null safety as the baseline for shared code. Ensures uniform Kotlin fluency before introducing multiplatform-specific patterns.

Lesson 1 • Multi-Module KMP Projects

Demonstrates splitting a KMP project into multiple Gradle modules for scalability. Students configure inter-module dependencies and understand build performance trade-offs.

Lesson 2 • Source Set Hierarchy Explained

Details commonMain, platform-specific source sets, and intermediate source sets. Understanding hierarchy is prerequisite to all shared code design decisions in the course.

Lesson 3 • Expect and Actual Declarations

Explains the expect/actual mechanism for declaring platform-specific implementations from shared code. Students implement platform APIs without breaking the common module contract.

Lesson 1 • Coroutine Dispatchers in KMP

Explains how dispatchers differ across Android, iOS, and JVM targets in KMP. Students configure platform-appropriate dispatchers using expect/actual patterns.

Lesson 2 • Exposing Coroutines to iOS

Addresses the challenge of consuming Kotlin coroutines from Swift, which lacks native coroutine support. Students use wrappers and libraries to bridge async code to iOS.

Lesson 3 • Coroutine Fundamentals

Introduces suspend functions, coroutine builders, and the coroutine lifecycle. These concepts underpin every async operation in shared KMP modules.

Lesson 4 • Kotlin Flow for Reactive Streams

Covers cold flows, state flows, and shared flows for reactive data pipelines in shared code. Students build observable data layers consumed by both Android and iOS UIs.

Lesson 1 • Parsing and Mapping API Responses

Covers deserializing JSON responses into Kotlin data models and mapping them to domain objects. Clean data mapping keeps platform UIs decoupled from raw API contracts.

Lesson 2 • kotlinx.serialization Fundamentals

Introduces the kotlinx.serialization library for encoding and decoding data in shared code. Serialization is the foundation for all network and storage data handling.

Lesson 3 • Handling Network Errors and Retries

Implements robust error handling, timeout configuration, and retry logic in the shared Ktor client. Resilient networking improves app reliability across unstable mobile connections.

Lesson 4 • Testing the Network Layer

Uses Ktor's MockEngine to write unit tests for the shared network layer without real HTTP calls. Testable networking code reduces regression risk during API changes.

Lesson 1 • Introduction to SQLDelight

Explains SQLDelight's compile-time SQL verification and type-safe query generation. Students understand how SQLDelight differs from ORM approaches before writing schemas.

Lesson 2 • Integrating SQLDelight with Coroutines

Wraps SQLDelight queries in flows and suspend functions for reactive data access. Coroutine integration connects the database layer to the shared ViewModel or repository.

Lesson 3 • Multiplatform Settings for Key-Value Storage

Introduces the multiplatform-settings library for storing preferences in shared code. Key-value storage is the simplest persistence layer and a prerequisite for database work.

Lesson 4 • Defining Schemas and Queries

Covers writing .sq files to define tables, inserts, updates, and selects. Generated Kotlin APIs from SQL files form the data access layer used by shared repositories.

Lesson 1 • Testing with Dependency Injection

Replaces real dependencies with fakes and mocks in Koin test modules. Isolated unit tests validate shared logic without requiring platform runtimes.

Lesson 2 • Wiring Repositories and Use Cases

Demonstrates injecting repositories, data sources, and use cases through Koin modules. Students build a complete dependency graph for the shared business logic layer.

Lesson 3 • Dependency Injection Principles

Reviews DI concepts including inversion of control, service locator, and constructor injection. Conceptual grounding ensures students choose the right DI approach for KMP.

Lesson 1 • Integrating Shared Code in iOS

Consumes the shared Kotlin framework from SwiftUI using ObservableObject wrappers. Students bridge Kotlin state flows to Swift's Combine or async/await patterns.

Lesson 2 • Platform-Specific Feature Implementation

Uses expect/actual to implement platform features such as camera access, notifications, and biometrics. Students extend shared APIs with native capabilities without breaking common code.

Lesson 3 • End-to-End Feature Delivery

Assembles networking, storage, DI, and UI layers into a complete working feature. Students validate the full vertical slice on both Android and iOS devices.

Lesson 4 • Integrating Shared Code in Android

Connects the shared module to Jetpack Compose UI on Android using standard ViewModel integration. Students observe shared state flows and dispatch events from Compose screens.