Course
Overview
Kotlin is a modern, concise, and safe language that has established itself on the JVM, on Android, and well beyond. Its clear and expressive syntax lets you write less code, with fewer errors.
Designed for developers who already know at least one other language, this course gives you a solid foundation to quickly become productive in Kotlin.
You will discover the essential concepts of the language: classes, interfaces and sealed types, nullability and smart casts, function types and generics, the standard library and collections, property management, data classes, Java interoperability, and code quality tools.
By the end of these three days, you will be able to write idiomatic, safe, and readable Kotlin code, and to integrate it confidently into your existing projects.
Program
Objectives
Understand the language concepts: classes, interfaces, enums, sealed classes, and objects.
Write safe code thanks to nullability, smart casts, and exception handling.
Work with function types, generics, and typealiases.
Use the standard library effectively: collections, ranges, and scope functions.
Manage properties and model immutable data with data classes and value classes.
Make Kotlin and Java coexist in the same project.
Ensure code quality: tests, IDEA tooling, and static analysis.
Prerequisites
Knowing at least one other programming language (Java, C#, Python, JavaScript, Swift…) and mastering its fundamental concepts. No prior knowledge of Kotlin is required.
Program
D1
The language concepts and its type system
Morning
Interfaces & classes
understand object modeling in Kotlin
Enums, sealed classes & objects
model closed hierarchies and singletons
Exclusive types
branch with when on exclusive types
Contexts
extend existing types
DSL
with infix and operators
lazy & lateinit
defer initialization
Varargs
pass and propagate variable arguments
Exceptions
handle errors
Afternoon
Nullability & smart casts
null safety guaranteed by the compiler
Function types
treat functions as values
Resource management
cleanly release resources
Generics
parameterize types and functions
Typealiases
bypass the type system
Reification
with constructor functions
D2
Standard library, properties, and immutability
Morning
Collections
work with mutable and immutable collections
Immutable collections
the power of true immutability
Ranges
work with intervals
Scope functions
write expressive one-liners
Afternoon
Accessors
work with getters and setters
Validation
validate properties
Typed fields
type fields for private use
Delegation
delegate property access
Data classes
store immutable values
Value classes
inlined values with no overhead
D3
Java interoperability and code quality
Morning
Nullability
how it translates between Kotlin and Java
Functions & classes
expose them to Java
Statics
expose static members
Overloading
handle overloads
Afternoon
Tests
write and run tests
Build
configure the build for code quality
IDEA tooling
take advantage of the IDE
Static analysis
ensure code quality
Details
- Format
In-company
- Duration
3 days (21 hrs)
- Audience
Developers proficient in at least one other language
These trainings might interest you
Our workshops are designed for professionals. Each program is tailored to your team's level and context, whether in-house or as an open session.
Kotlin Multiplatform: Mobile
Share your business logic between Android and iOS without sacrificing the native experience: master the Kotlin Multiplatform toolchain and Swift interoperability to design, distribute, and integrate a robust shared SDK that accelerates your teams.
Compose: Interfaces in All Their Forms
Embrace declarative thinking to build reactive, maintainable, and performant interfaces. Master state and data flow to share a single UI codebase across Android, iOS, Desktop, and Web.
The Kotlin Language: Expertise for Deploying APIs
Go beyond everyday Kotlin: understand the deep mechanisms of the language and compiler to write idiomatic, safe code, design durable public APIs, and automate code generation.
Kotlin Coroutines: Expert Usage
Go beyond everyday coroutine usage: understand their inner mechanisms, from language primitives to flows, to write reliable, performant, and testable asynchronous code, and choose the right tool for each problem.
Koog: Integrating AI into Your Multiplatform Apps
Go beyond the simple LLM call: use Koog to design AI agents integrated into your Kotlin applications, capable of acting and orchestrating themselves, reliable, cost-efficient, and observable in production.
Gradle: Master & Optimize Your Builds
Finally understand what happens in your Gradle builds to make them reliable, fast, and maintainable: factor out your configuration, automate your specific needs, and save precious time on every build.