1. Meet Kotlin and the JVM
BeginnerUnderstand Kotlin's purpose, project structure, compiler, and basic syntax.
Your first Kotlin program
A Kotlin command-line application commonly starts in a top-level main function.
Run and compile Kotlin
The Kotlin compiler and build tools turn source code into runnable output.
Comments, names, and basic syntax
Kotlin uses case-sensitive names and supports line and block comments.
Module checkpoint: Practice this module by writing a small Kotlin program that uses meet kotlin and the jvm, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
2. Variables, Types, and Expressions
BeginnerDeclare immutable and mutable values and work with Kotlin's core types.
Immutable and mutable variables
val prevents reassignment of a reference, while var permits reassignment.
Numbers, Boolean, and characters
Kotlin provides statically typed numeric and logical values.
Strings and string templates
String templates embed expressions directly in readable text.
Module checkpoint: Practice this module by writing a small Kotlin program that uses variables, types, and expressions, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
3. Operators, Conditions, and Ranges
BeginnerBuild expressions and express conditional logic using Kotlin syntax.
Arithmetic and comparison operators
Operators calculate values and compare expressions.
Conditions and if expressions
In Kotlin, if can select and return a value.
when branches and ranges
when can replace long conditional chains, and ranges express intervals.
Module checkpoint: Practice this module by writing a small Kotlin program that uses operators, conditions, and ranges, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
4. Loops, Collections, and Iteration
BeginnerRepeat operations and process collections without off-by-one errors.
for loops and ranges
A for loop iterates over values supplied by a range or collection.
while, do-while, and repeat
Different loop forms suit condition-driven and count-driven repetition.
Control loop flow
break exits a loop and continue skips to the next iteration.
Module checkpoint: Practice this module by writing a small Kotlin program that uses loops, collections, and iteration, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
5. Functions, Lambdas, and Scope
BeginnerCreate reusable functions and use default arguments, named arguments, and lambdas.
Function parameters and return values
Functions group reusable behavior behind a clear signature.
Default and named arguments
Default values reduce overloads, and named arguments clarify call sites.
Lambdas and lexical scope
A lambda is a function literal that can be stored or passed to another function.
Module checkpoint: Practice this module by writing a small Kotlin program that uses functions, lambdas, and scope, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
6. Null Safety and Type Modeling
IntermediateModel optional values safely and represent alternatives with Kotlin's type system.
Nullable and non-null types
Kotlin encodes whether a variable may hold null in its type.
Safe calls and the Elvis operator
Safe calls and Elvis expressions provide concise nullable-value handling.
Enums and sealed hierarchies
Enums represent a fixed set of values; sealed types model a controlled set of variants.
Module checkpoint: Practice this module by writing a small Kotlin program that uses null safety and type modeling, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
7. Classes and Object-Oriented Kotlin
IntermediateCreate classes and data classes and understand properties, constructors, and inheritance.
Classes and constructors
A class defines a type, and a constructor initializes instances.
Data classes and properties
Data classes provide useful value-oriented methods for property-based models.
Interfaces and inheritance
Interfaces define contracts and open classes support controlled inheritance.
Module checkpoint: Practice this module by writing a small Kotlin program that uses classes and object-oriented kotlin, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
8. Collections and Functional Operations
IntermediateChoose suitable collection types and process data with standard collection operations.
Lists, sets, and maps
Each collection type expresses a different way to organize values.
Mutable collections and safe updates
Mutable collections support updates while read-only APIs can limit accidental changes.
Filter, map, and sorting
Collection operations make data transformations explicit and composable.
Module checkpoint: Practice this module by writing a small Kotlin program that uses collections and functional operations, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
9. Generics, Extensions, and Delegation
IntermediateWrite reusable type-safe code and extend existing APIs without unnecessary inheritance.
Generic functions and classes
Generics allow reusable code to preserve type information.
Extension functions and properties
Extensions add callable syntax to a type without changing its source code.
Composition and delegation
Delegation forwards an interface implementation to another object.
Module checkpoint: Practice this module by writing a small Kotlin program that uses generics, extensions, and delegation, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
10. Exceptions, Files, and Serialization
IntermediateHandle failures and work with files and structured data responsibly.
Exceptions and failure paths
try and catch handle exceptional failures at a boundary where recovery is possible.
Reading and writing files
File operations should specify their expected paths, encodings, and error behavior.
JSON and serialization boundaries
Structured formats need an explicit mapping between domain data and external representations.
Module checkpoint: Practice this module by writing a small Kotlin program that uses exceptions, files, and serialization, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
11. Coroutines and Concurrency
AdvancedUnderstand threads, structured concurrency, and coroutine-based asynchronous work.
Threads and shared state
Concurrency allows work to make progress during overlapping periods; parallelism means work executes at the same time.
Suspend functions and coroutines
Coroutines can suspend without blocking the underlying thread when using a compatible suspending operation.
Structured concurrency and cancellation
Structured concurrency ties child tasks to a defined lifecycle.
Module checkpoint: Practice this module by writing a small Kotlin program that uses coroutines and concurrency, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
12. Testing, Build Tools, and Project Structure
AdvancedOrganize a Kotlin project for maintainability with automated checks and reliable builds.
Packages, imports, and Gradle
Packages organize source names, while Gradle manages repeatable JVM project builds.
Unit testing with Kotlin
Tests verify observable behavior for normal, boundary, and failure cases.
Debugging and code quality
Formatting, diagnostics, tests, and focused reviews improve reliability.
Module checkpoint: Practice this module by writing a small Kotlin program that uses testing, build tools, and project structure, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.
13. HTTP APIs and Application Design
AdvancedApply Kotlin skills to basic service design, configuration, and production readiness.
HTTP clients and APIs
HTTP defines requests and responses that application code should validate and handle explicitly.
Input validation and configuration
Validate untrusted input at boundaries and keep environment configuration separate from code.
Release readiness and application boundaries
Clear layers and repeatable checks make a small Kotlin application maintainable.
Module checkpoint: Practice this module by writing a small Kotlin program that uses http apis and application design, then test a normal case, an empty or boundary case, and one invalid or unexpected input. Explain why the result is correct before running the code.