2 tracks · 19 courses · 161 lessons. Each course builds on the previous one — but you can also jump in where you like.
Kotlin from the ground up: syntax, object orientation, functional patterns, concurrency and the internals of the JVM and compiler. The courses build on each other.
0 / 111 lessons completed in total
The basics of Kotlin syntax for absolute beginners: variables, types, control flow, functions, null safety, strings and simple input and output. This course is the prerequisite for all other Kotlin courses on this platform.
[KOTLIN]List, Set and Map in detail: read-only vs. mutable, safe access to elements, the most important operations for filtering, transforming and aggregating, and sequences as a performant alternative to collections. Builds on "Kotlin Introduction".
[KOTLIN]Classes, inheritance, interfaces and Kotlin's special class kinds (data, sealed, enum) — for everyone who already knows the basics (variables, control flow, functions, null safety) from "Kotlin Introduction" and now wants to learn how to build programs from objects instead of individual functions.
[KOTLIN]Functions as values, higher-order functions, extension functions, scope functions and immutability — the functional tools that make Kotlin code shorter and clearer. Builds on "Kotlin Introduction" and "Kotlin OOP".
[KOTLIN]try/catch/finally, custom exceptions, why Kotlin has no checked exceptions, and the idiomatic alternatives (nullable return values, the Result type) — for everyone who already knows the basics from "Kotlin Introduction" and "Object-Oriented Programming in Kotlin" and now wants to learn how to model errors cleanly in Kotlin instead of just catching them.
[KOTLIN]Generic classes and functions, type bounds, variance (in/out), type projections, type erasure, and inline and reified functions — for everyone who has already completed "Kotlin Introduction" and "Kotlin OOP".
[KOTLIN]Why software needs tests, how JUnit 5 is set up in Kotlin projects, and how to write code that can be tested at all. Builds on "Kotlin Introduction" and "Kotlin OOP".
[KOTLIN]What actually happens when `kotlinc` compiles your code: bytecode, class files, memory management and garbage collection on the JVM, the compiler pipeline from lexer to codegen, the modern K2 compiler, and what data classes or inline functions really trigger in the bytecode. For anyone who has finished "Kotlin Introduction" and "Object-Oriented Programming" and wants to understand what runs under the hood.
[KOTLIN]How Kotlin source code becomes a runnable artifact: Gradle with the Kotlin DSL, compared to Maven. build.gradle.kts, project structure, plugins, dependencies, tasks and version management — the toolkit every real Kotlin project needs. Requires the course "Kotlin Introduction".
[KOTLIN]Concurrency without thread chaos: suspend functions, coroutine builders, structured concurrency, cancellation, exception handling and Flows — the toolkit that makes Kotlin's asynchronous code as readable as sequential code.
[KOTLIN]What really happens under coroutines: threads, race conditions, locks and atomics on the JVM — and how dispatchers and mutex pick up these concepts again in the coroutines world. Builds on "Kotlin Introduction", "Kotlin OOP" and basic coroutines knowledge.
[KOTLIN]KClass, callable references and introspection at runtime — how frameworks, test tools and serializers work with classes they do not even know at compile time. And just as important: when to leave it alone. Builds on "Kotlin Introduction", "Kotlin OOP" and "Kotlin Generics".
Unlocks at 100% course progress (0 / 111 lessons).
Unlocks at 100% course progress (0 / 111 lessons).
Complete all courses and the final project of this track to receive your certificate.
How to build software that stays understandable and changeable: clean code, SOLID, design patterns, architecture, testing, collaboration and security — the engineering principles behind the code, illustrated with Kotlin.
0 / 50 lessons completed in total
You spend far more time reading code than writing it — your own included. This course shows how to name, structure and shape code so that it stays understandable months later. It starts with names and small functions, moves to the principles behind good structure, and ends by hunting down the smells that make code expensive to change.
[PRINCIPLES]Good object-oriented design is not about using every feature of the language. This course walks through the five SOLID principles and the composition rule behind them, with a concrete business example for each: what problem the principle solves, how to apply it in Kotlin, and where it stops paying off. By the end you can look at a class and say which reason would make it change.
[PRINCIPLES]Design patterns are named solutions to problems that keep coming back. This course covers the creational, structural and behavioral patterns that matter most in everyday application code. Each pattern is shown with the problem first, then the solution, and an honest look at when it is the wrong tool. Patterns are vocabulary, not goals.
[PRINCIPLES]Architecture is not about drawing boxes. It is about choosing where the seams go so the system can change without breaking. This course starts with layers and the direction of dependencies, moves through the classic UI patterns MVC, MVP and MVVM, and ends at boundaries and the honest question of when architecture is worth its cost.
[PRINCIPLES]Tests are how you change code without fear. This course covers the levels of a healthy test suite, how to structure and name a test so it explains itself, how test-driven development shapes design, and how test doubles and boundary thinking find the bugs that hide in the edges. It closes with code review and automated quality gates.
[PRINCIPLES]Version control is not a backup tool, it is how a team thinks together. This course covers the daily mechanics of Git (commits, branches, merging and rebasing) and then the human side: pull requests, a shared commit convention and code review that improves the work instead of the mood.
[PRINCIPLES]Software that works only for the happy path is not finished. This course is about handling errors deliberately, failing fast, validating at the boundary and keeping secrets out of the code. It ends with the security risks every application faces and the twelve-factor rule for configuration.
Complete all courses and the final project of this track to receive your certificate.