Practical Kotlin Deep Dive Course

Preface

Who This Course Is For

What This Course Covers

How to Use This Course

Course Structure

Quizzes and Exercises

Earning Your Certificate

Staying Current

Chapter Overview

Null Safety in Kotlin

The Core Principle: A Tale of Two Types

1. Non-Nullable Types

2. Nullable Types

Safely Working with Nullable Types

1. The Safe Call Operator (?.)

2. The Elvis Operator (?:)

3. The Not-Null Assertion Operator (!!)

4. Smart Casts and Safe Casts

Interoperability with Java and Platform Types

Summary

The Any, Unit, and Nothing Types

Any: The Root of the Type Hierarchy

Unit: Representing the Absence of a Meaningful Value

Nothing: The Type That Has No Values

1. For Functions That Never Return

2. As the Bottom of the Type Hierarchy

Summary

Structural and Referential Equality

Summary

💡 Pro Tips for Mastery: How does structural equality (==) work internally?

The First Line of Defense: The Safe Call Operator (?.)

The Null-Handling Bridge: The Elvis Operator (?:)

The Final Verdict: The Referential Null Check (b === null)

Why This Design is Great

Bonus: The null + null Operation

Why This is Important

Summary

Variables: var vs val

Summary

💡 Pro Tips for Mastery: Why is the val variable and property read-only and not immutable?

Summary

Visibility Modifiers

Public

Private

Protected

Internal

Summary

💡 Pro Tips for Mastery: How internal visibility modifier is compiled to Java Bytecode?

The init Block

Key Features of the init Block

Example of the init Block

Benefits of Using the init Block

Important Considerations

Summary

💡 Pro Tips for Mastery: What are the downsides of init block?

1. Unintended Side Effects

2. Limited Flexibility

3. Tightly Coupled Initialization Logic

4. Performance Impact

5. Challenging Debugging

Best Practices to Mitigate Downsides

Summary

💡 Pro Tips for Mastery: How init block is compiled to Java Bytecode?

Backing Fields and Backing Properties

Backing Fields

Backing Properties

Key Differences

Summary

Data Classes

Key Characteristics

Key Features of Data Classes

Differences Between Data Class and Regular Class

Summary

💡 Pro Tips for Mastery: Data class inheritance

💡 Pro Tips for Mastery: The visibility of the copy function of data classes

💡 Pro Tips for Mastery: Unveiling a data class in Java Bytecode

Conclusion

Sealed Classes

Key Characteristics of Sealed Classes

When to Use Sealed Classes

💡 Pro Tips for Mastery: Sealed class inheritance

💡 Pro Tips for Mastery: What are the differences between sealed classes and sealed interfaces?

Inheritance

Flexibility and Use Cases

Sealed Class Example

Sealed Interface Example

Sealed interfaces and sealed classes freedom

Summary

Enum Classes

Adding Properties and Methods

Using Enum Constants

Commonly Used Properties and Methods

Use Cases

Summary

💡 Pro Tips for Mastery: Generic values() and valueOf() for enums

Advantages

Backward Compatibility

Impact on Reflection and Libraries

Summary

💡 Pro Tips for Mastery: Decommission Enum.values() and replace it with Enum.entries

💡 Pro Tips for Mastery: What are the differences between a sealed class and an enum class?

Example Code

Key Features

Use Cases

Summary

Value Classes

Key Features

Syntax Example

Benefits of Value Classes

Constraints of Value Classes

The Real-World Use Case

Summary

💡 Pro Tips for Mastery: What are the differences between value classes and inline classes?

Inline Classes

Value Classes

Inline classes are user-defined value classes

@JvmInline annotation for value classes

Summary

💡 Pro Tips for Mastery: How value class is compiled to Java Bytecode

💡 Pro Tips for Mastery: @JvmExposeBoxed - Bringing Kotlin’s value classes for Java

@JvmExposeBoxed

Inner and Nested Classes

Declaring an Inner Class

Accessing the Outer Class Instance

Differences Between Nested and Inner Classes

Use Cases of Inner Classes

Drawbacks of Inner Classes

Summary

💡 Pro Tips for Mastery: Decompiling differences for inner class vs. nested class in Java Bytecode

Object Declarations

Key Characteristics

Example of an Object

Use Cases

Differences Between Object and a Regular Class

Summary

💡 Pro Tips for Mastery: Object declarations vs. expressions

Object Declarations: The Singleton Pattern, Simplified

Object Expressions: Anonymous, One-Time Instances

What are the key differences?

Summary

💡 Pro Tips for Mastery: What is a data object?

Key Features

Example of a Data Object

Use Cases

Data Class vs. Object vs. Data Object

KEEP’s Data objects Proposal

Summary

💡 Pro Tips for Mastery: How Kotlin’s object is compiled to Java Bytecode

Companion Objects

Key Characteristics of Companion Objects

Interoperability with Java and @JvmStatic

When to Use Companion Objects

Key Benefits

Summary

Delegated Properties

How Delegated Properties Work

Common Use Cases for Delegated Properties

Local delegated properties

Summary

💡 Pro Tips for Mastery: Internal mechanisms of Lazy

The Internal State Management: UNINITIALIZED_VALUE

💡 Pro Tips for Mastery: How lazy() delegate property is compiled to Java Bytecode?

Lazy Initialization vs lateinit

Key Differences

Local and top-level lateinit vars

Summary

💡 Pro Tips for Mastery: How can you check if a lateinit property has been initialized?

Lateinit property isInitialized intrinsic

💡 Pro Tips for Mastery: How lateinit is compiled to Java Bytecode

Higher-Order Functions

Syntax

Example: Passing a Function as a Parameter

Example: Returning a Function

Real-World Use Cases

Advantages of Higher-Order Functions

Summary

💡 Pro Tips for Mastery: How are higher-order functions compiled into Java bytecode?

Transformation into Function Interfaces

Lambda Conversion

Optimizations Using InvokeDynamic

Inline Functions and Bytecode Optimization

Summary

Lambda Expressions

Shorthand Syntax

Usage with Higher-Order Functions

Capturing Variables from the Scope

Summary

The inline Keyword

How inline Works

Benefits of Using inline

Enabling Advanced Language Features: Non-Local Returns

Reified Generics with inline

When Not to Use inline

Summary

💡 Pro Tips for Mastery: What is an inline property? What advantages can you take from it?

Advantages of Inline Properties

Limitations

Inline for property accessors

Summary

💡 Pro Tips for Mastery: How do functions like repeat(), map(), and filter() accept suspending functions in their lambdas despite not having coroutine-aware signatures?

Why Inline Functions Enable This Behavior

Summary

The reified Keyword

Key Use Cases

Benefits of Using reified

Limitations of reified

Example: Using reified for Filtering a List by Type

Summary

💡 Pro Tips for Mastery: How inline and reified functions are compiled to Java Bytecode

Functional (SAM) Interfaces

SAM Conversion

Key Features of Functional Interfaces

Summary

💡 Pro Tips for Mastery: A philosophy of SAM conversion

The Philosophical Bridge: A Function is an Object (and Vice Versa)

Kotlin’s Implementation: A Commitment to Interoperability

The Evolution in Java and the Continuing Relevance in Kotlin

Summary

Extension Functions

Pros of Extensions

Cons of Extensions

Summary

💡 Pro Tips for Mastery: How are Kotlin extension functions compiled into Java bytecode?

Advantages of This Compilation Approach

Limitations

Summary

💡 Pro Tips for Mastery: JvmSynthetic annotation

1. Kotlin Extension Functions: A Syntactic Sugar over Static Methods

2. The @JvmSynthetic Annotation: Hiding from Java

3. Case Study: internal Functions and @JvmSynthetic

Summary

Domain-Specific Languages (DSL)

How Kotlin DSL Works

Another Example of HTML Builder

Advantages of This Approach

Summary

Chapter Summary

Key Terms

Important Concepts

What to Remember

Chapter Overview

Collection Types

Read-Only Collection Types

Mutable Collection Types

Understanding Mutability of Read-Only and Mutable Collections

Summary

💡 Pro Tips for Mastery: What are the differences between listOf() and emptyList()?

listOf()

emptyList()

Summary

Transformation Operators

map and mapIndexed

flatMap and flatten

groupBy and associateBy

zip and unzip

filter, filterNot, and filterIndexed

The Role of inline

Summary

Iterators

Key Features of Iterator

Examples of Using Iterator

MutableIterator

Key Features of MutableIterator

Examples of Using MutableIterator

Summary

Sequences

Creating a Sequence

Transforming Sequences

The Terminal Operation

Summary

Retrieving Parts of Collections

subList

slice

take and takeLast

drop and dropLast

windowed

chunked

Summary

Defining Object Ordering

Sorting Functions

Reversing the Order

Randomizing the Order

Summary

Understanding Scope Functions

let

run

with

apply

also

Choosing the Right Scope Function

Summary

Chapter Summary

Key Terms

Transformation Operations

Collections vs Sequences

Scope Functions

Important Concepts

What to Remember

Chapter Overview

Coroutines

How Coroutines Work

Launching Coroutines

Suspending Functions

Summary

💡 Pro Tips for Mastery: Coroutines Terminology

Summary

Continuation

How Continuations Work

How Kotlin Compiler Transforms Suspend Functions

Summary

Coroutines vs Threads

1. Management and Creation

Threads (OS Kernel Management)

Coroutines (User-Space Management)

2. Scheduling and Context Switching

Threads (Preemptive Multitasking)

Coroutines (Cooperative Multitasking)

3. State, Memory, and Blocking

Threads (Stackful and Blocking)

Coroutines (Stackless and Suspending)

Comparison Example

Relationship Between Coroutines and Threads

Summary

💡 Pro Tips for Mastery: What are the differences between multi-threading and multi-processing?

Memory Management

Execution Model

Resource Utilization

Fault Tolerance

Scalability

Summary

💡 Pro Tips for Mastery: Coroutine Execution and Mutable State Management

Why Mutable State Sharing Is Risky

Safe Data Sharing in Single-Threaded Dispatchers

Handling Multi-threaded Environments

How Threads Interact with Coroutines

Summary

Coroutine Builders

1. launch

2. async

3. runBlocking

4. produce (for Channels)

5. actor (for Actors Model)

Summary

💡 Pro Tips for Mastery: What are the differences between launch and async?

The Core Difference: Return Value and Intent

Error Handling and Structured Concurrency

Summary

💡 Pro Tips for Mastery: Why should you use runBlocking with caution?

When To Use runBlocking?

Summary

💡 Pro Tips for Mastery: Internal mechanisms of the AbstractCoroutine

How Completion and Resumption Works: resumeWith

Structured Concurrency: The Parent-Child Link

Summary

Coroutine Context

Elements of Coroutine Context

Creating a Custom Coroutine Context

Accessing Coroutine Context

Summary

💡 Pro Tips for Mastery: CoroutineContext interface

Core Operations in Coroutine Context

Elements in Coroutine Context

Standard Library Context Elements

Accessing Coroutine Context

Summary

Job

Internal Mechanisms of Job

Structured Concurrency: The Parent-Child Link and Completion/Waiting

Summary

💡 Pro Tips for Mastery: What’s a SupervisorJob?

When to Use a SupervisorJob

Real-world Use Case

Internals of SupervisorJob

Summary

Coroutine Scope

Common Coroutine Scopes

(1) GlobalScope

(2) MainScope

(3) viewModelScope (Lifecycle-Aware Scopes)

(4) lifecycleScope (Lifecycle-Aware Scopes)

Example: Creating a Custom Coroutine Scope

Summary

💡 Pro Tips for Mastery: Why should you use GlobalScope carefully?

The Dangers of Unstructured Concurrency

Legitimate (But Rare) Use Cases

The Correct Alternative: Structured Scopes

Summary

💡 Pro Tips for Mastery: What is the coroutineScope() function?

Error and Cancellation Handling

When to Use coroutineScope()

coroutineScope() internals

Summary

💡 Pro Tips for Mastery: What is the supervisorScope() function?

Why Use supervisorScope

Summary

What kind of coroutine dispatchers exist, and what’s their purpose?

Choosing the Right Dispatcher

CoroutineDispatcher

Summary

💡 Pro Tips for Mastery: Differences between CPU-intensive tasks and I/O tasks

CPU-Intensive Tasks

I/O-Intensive Tasks

Thread Behavior

CPU-Intensive Tasks vs. I/O-Intensive Tasks

Summary

💡 Pro Tips for Mastery: Internals of Dispatchers

The Shared Engine: CoroutineScheduler and SchedulerCoroutineDispatcher

Dispatchers.Default: The CPU-Bound Workhorse

Dispatchers.IO: I/O-Bound Specialist

Dispatchers.Main: The Platform-Specific UI Thread

Dispatchers.Unconfined: The Unpredictable Executor

Summary

What are channels and how do they work?

1. Rendezvous Channel (capacity = Channel.RENDEZVOUS or 0)

2. Buffered Channel (capacity > 0)

3. Conflated Channel (capacity = Channel.CONFLATED)

4. Unlimited Channel (capacity = Channel.UNLIMITED)

Summary

💡 Pro Tips for Mastery: Internals Mechanisms of Channel

What are the join() and yield() functions?

1. join() Function

2. yield() Function

Key Differences

Summary

How do you handle exceptions in coroutines?

1. try-catch Block

2. Delegate Exception Propagation with CoroutineExceptionHandler

3. SupervisorJob

Summary

💡 Pro Tips for Mastery: The special nature of CancellationException

Re-throwing CancellationException for Graceful Exit

The runCatching Problem

When NOT to Rethrow CancellationException

Flow’s Approach: A Model to Follow

Summary

💡 Pro Tips for Mastery: Handling exception propagation when using async

How to Handle

Summary

What are the differences between cold flow and hot flow?

Cold Flow

Hot Flow

Key Differences Between Cold Flow and Hot Flow

Summary

💡 Pro Tips for Mastery: Internal mechanisms of Flow and AbstractFlow

The flow { … } Builder: The Standard Implementation

The AbstractFlow Base Class: Enforcing Context Preservation

How Intermediate Operators Work

Summary

Explain the differences between StateFlow and SharedFlow

StateFlow

SharedFlow

Key Differences Between StateFlow and SharedFlow

Summary

💡 Pro Tips for Mastery: Internal Mechanisms of StateFlow

The State-Holding Mechanism

The Update Mechanism: updateState() and Synchronization

The Collection Mechanism: collect() and StateFlowSlot()

Summary

💡 Pro Tips for Mastery: Internal Mechanisms of SharedFlow

The Core Data Structure: A Circular Buffer and Indices

The emit Mechanism: A Synchronized State Update

The collect Mechanism: The Subscriber’s State Machine

Summary

What does the Flow.flowOn() operator do?

Summary

💡 Pro Tips for Mastery: Internal Mechanisms of flowOn

The ChannelFlowOperatorImpl: The Coroutine Boundary

Summary

How Flow.buffer() operator works?

When to Use buffer()

Summary

💡 Pro Tips for Mastery: Internal Mechanisms of Flow.buffer()

The ChannelFlowOperatorImpl Mechanism: A Producer-Consumer Model

Summary

How Kotlin’s internal mechanisms optimize Flow with FusibleFlow and ChannelFlow

The Solution: FusibleFlow and Operator Fusion

ChannelFlow: The Concrete Fusible Implementation

The ChannelFlowOperator and the Fast Path

Summary

What are the differences between launchIn(Scope) and Scope.launch()?

scope.launch { flow.collect() }

flow.launchIn(scope)

Summary

What are Flow transformation operators: flatMapLatest, flatMapMerge, flatMapConcat?

flatMapConcat: The Sequential Model

flatMapMerge: The Concurrent Model

flatMapLatest: The Cancellation Model

Key Differences

Summary

What are callbackFlow and channelFlow, and their internal mechanisms?

callbackFlow

channelFlow

Key Differences

Summary

Chapter Summary

Key Terms

Coroutine Builders

Dispatchers

Context Combination

Flow Operators

StateFlow vs SharedFlow

Important Concepts

What to Remember

Chapter Overview

Kotlinx Serialization

How Serialization Works

Customizing Serialization

JSON Configuration

Polymorphic Serialization

Multiplatform Support

Summary

Kotlinx Datetime

The Need for kotlinx-datetime

Working with Time Zones

Date Arithmetic

Duration and Period

Parsing and Formatting

Comparison with Java Time

Summary

Kotlinx Collections Immutable

The Problem with Read-Only Collections

Truly Immutable Collections

Persistent Collections

Builders for Efficient Bulk Operations

When to Use Immutable Collections

Performance Considerations

Summary

Other Notable KotlinX Libraries

kotlinx-atomicfu

kotlinx-io

kotlinx-benchmark

Dokka

kotlinx-rpc

Kover

Summary

Chapter Summary

Key Terms

kotlinx-serialization

kotlinx-datetime

kotlinx-collections-immutable

Important Concepts

What to Remember

Chapter Overview

Annotation Processors, KAPT, and KSP

Annotation Processor (Java APT)

KAPT (Kotlin Annotation Processing Tool)

KSP (Kotlin Symbol Processing)

Performance Comparison

Key Differences

Migration from KAPT to KSP

Summary

Structure of the Kotlin Compiler

High-Level Architecture

Frontend

Backend

Backend Processing Stages

Key Differences: Frontend vs. Backend

The Role of IR

Summary

The K2 Compiler

Why K2?

Key Improvements

FIR Compilation Phases

K2 for Plugin Authors

Migration to K2

Compatibility Considerations

Summary

FIR in the K2 Compiler

Why FIR?

FIR Element Hierarchy

FIR Resolution Phases

Working with FIR: Symbols and Providers

Building FIR Elements

FIR Scopes

ConeKotlinType: The Type System

Summary

IR and the Kotlin Backend

The Role of IR

IR Tree Structure

Key IR Element Types

IR Lowering: High-Level to Low-Level

Platform-Specific Backends

IR Plugin Context

IR Transformation Patterns

IR Serialization

Summary

How to Write a Kotlin Compiler Plugin

Plugin Architecture Overview

Step 1: Define Your Annotation

Step 2: Create the Command Line Processor

Step 3: Create the Component Registrar

Step 4: Register Services (SPI)

Step 5: Implement K2 FIR Extension

Step 6: Implement IR Generation Extension

Step 7: Create Gradle Plugin

Step 8: Usage in Projects

Summary

Compiler Plugin Use Cases

Kotlinx Serialization

Jetpack Compose

Parcelize

All-Open and No-Arg Plugins

SAM-with-Receiver

When to Consider Writing a Compiler Plugin

Summary

Chapter Summary

Key Terms

Compiler Architecture

KAPT vs KSP

FIR Resolution Phases

IR Lowering Transformations

Compiler Plugin Structure

Real-World Plugin Examples

Important Concepts

What to Remember

Chapter Overview

Kotlin Multiplatform Overview

Key Features of Kotlin Multiplatform

Key Advantages

Kotlin Multiplatform Architecture

Summary

Expect and Actual Declarations

Expect Declarations

Actual Implementations

What Can Be Expected/Actual

Default Implementations with Expected Classes

Compiler Guarantees

When to Use Expect/Actual vs Other Approaches

Summary

Concurrency and Asynchronous Programming

Kotlin Coroutines: The Primary Solution

Platform-Specific Dispatchers

Structured Concurrency in Multiplatform

Alternative Asynchronous Solutions

Summary

HTTP Network Communication

Ktor Client

Platform-Specific Engines

Ktorfit

Summary

Compose Multiplatform

How Compose Multiplatform Works

Writing Shared UI

Supported Platforms and Stability (2025)

Resources and Platform Integration

Platform-Specific UI When Needed

Navigation and Architecture

Trade-offs to Consider

Summary

Source Sets in Kotlin Multiplatform

Default Source Set Hierarchy

Project Structure

Gradle Configuration

Intermediate Source Sets

Dependencies Per Source Set

Summary

Memory Management and Platform Interoperability

Kotlin/Native Memory Management

Interoperability with Objective-C and Swift

Controlling Swift/Objective-C Exposure

Using iOS Frameworks from Kotlin

Coroutines and Swift Async/Await

Performance Considerations

Summary

Testing in Kotlin Multiplatform

Common Test Structure

Test Source Set Configuration

Testing Coroutines

Platform-Specific Tests

Testing with Fakes and Mocks

Running Tests

Integration Testing

Summary

Dependency Injection in Kotlin Multiplatform

Why DI Matters in Multiplatform

Metro: Compile-Time DI with Kotlin Compiler Plugin

Koin: KSP-Based Compile-Time DI

Kodein-DI: Flexible Runtime Container

Manual Dependency Injection

Choosing the Right Approach

Constructor Injection Pattern

Summary

Chapter Summary

Key Terms

Source Set Hierarchy

Kotlin to Swift/Objective-C Mapping

Interop Annotations

Testing in KMP

Platform-Specific Dependencies

Important Concepts

What to Remember