30 Advanced Kotlin Backend Interview Questions for Experienced Developers

Structured concurrency is a programming paradigm that ensures the lifecycle of coroutines is bound to a specific scope (`CoroutineScope`). When a scope is cancelled, all coroutines launched within it are also cancelled automatically. This prevents resource leaks from forgotten or runaway coroutines and makes error handling much more robust, as a failure in one child coroutine can transparently cancel its parent and siblings.

• `launch`: A “fire-and-forget” coroutine builder. It starts a new coroutine that does not return a result to the caller. It returns a `Job` object, which can be used to wait for completion or to cancel the coroutine.
• `async`: Starts a new coroutine that computes a result. It returns a `Deferred` object, which is a light-weight future that promises a result of type `T`. You must call `.await()` on the `Deferred` object to get the result, which will suspend until the computation is complete.

A `CoroutineDispatcher` determines which thread or thread pool a coroutine uses for its execution.

• `Dispatchers.Default`: Backed by a shared pool of threads on the JVM. It’s used for CPU-intensive work that doesn’t block the thread (e.g., sorting a large list).
• `Dispatchers.IO`: Backed by a larger, on-demand pool of threads. It’s designed for offloading blocking I/O operations (like file I/O or blocking network calls).
• `Dispatchers.Main`: A context restricted to a single, main UI thread. It’s only available on UI-based platforms like Android.
• `Dispatchers.Unconfined`: Starts the coroutine in the caller’s thread but lets it resume in whatever thread was used by the suspending function. Its use is discouraged in most cases.

This distinction describes how a `Flow` emits data in relation to its collectors.

• Cold Flow (like the default `flow { … }` builder): A cold flow is like a blueprint. It does not start producing values until a terminal operator (like `.collect()`) is called on it. Each new collector triggers a new execution of the producer code.
• Hot Flow (like `SharedFlow` or `StateFlow`): A hot flow is active and producing values even when there are no collectors. New collectors will only receive values emitted after they start collecting. It’s used for broadcasting events to multiple consumers simultaneously.

While coroutines can run on a single thread, they can also be dispatched to multiple threads, requiring state protection.

1. Thread Confinement: The simplest approach is to confine all modifications of the shared state to a single-threaded coroutine context.
2. `Mutex`: Kotlin Coroutines provides a `Mutex` with suspending `lock()` and `unlock()` functions. A coroutine will suspend when waiting for the lock, rather than blocking the thread.
3. `StateFlow` and `SharedFlow`: These thread-safe hot flows are designed for state management and can be updated atomically.

`withContext` is a suspending function used to switch the `CoroutineContext` (and typically the `Dispatcher`) for a specific block of code. It’s primarily used to move a long-running or blocking operation off a specific thread. For example, you might use `withContext(Dispatchers.IO)` inside a coroutine running on the default dispatcher to perform a blocking database call without stalling other coroutines.

A `CoroutineExceptionHandler` is an optional element in a `CoroutineContext` used to handle uncaught exceptions from coroutines. It’s typically installed in a top-level scope. Because of structured concurrency, a failure in a child coroutine propagates up to its parent, cancelling it and its other children. The exception handler allows you to log or process these otherwise unhandled exceptions at the scope level.

An **`inline`** function instructs the compiler to copy the function’s bytecode directly into the call site, rather than invoking a normal function call. This avoids the overhead of a function call and is particularly useful for higher-order functions with lambda parameters, as it also prevents the creation of a function object for the lambda.

The **`reified`** keyword can be used with a type parameter on an `inline` function. It makes the type information of the generic parameter (`T`) available at runtime inside the function. This allows you to perform operations that are normally not possible with generics due to type erasure, such as checking `is T` or getting `T::class`.

Delegation is a design pattern where an object handles a request by delegating it to another helper object. Kotlin provides first-class support for this pattern with the `by` keyword.

• Class Delegation: A class can delegate the implementation of an interface to another object. Example: `class MyList(innerList: List) : List by innerList { … }`.
• Property Delegation: A property’s get/set logic can be delegated to another object that implements `ReadProperty` and/or `ReadWriteProperty` operators. This is the mechanism behind `lazy`, `observable`, and custom delegates.

A **sealed class** is an abstract class that restricts the class hierarchy. All direct subclasses of a sealed class must be declared in the same file. This gives the compiler complete knowledge of all possible types. The primary benefit is in `when` expressions: the compiler can verify that you’ve covered all possible subclasses, removing the need for an `else` branch. This makes it perfect for modeling restricted hierarchies, like states in a state machine or different types of API responses (e.g., `Success`, `Error`, `Loading`).

Scope functions are functions that execute a block of code within the context of an object. They differ by what they return (the context object or the lambda result) and how they refer to the context object (`this` or `it`).

• `apply`: The context object is `this`. It returns the context object. Useful for object configuration. Example: `val person = Person().apply { name = “John”; age = 30 }`.
• `let`: The context object is `it`. It returns the lambda result. Useful for null checks and chaining operations. Example: `person?.let { println(it.name) }`.

Extension functions allow you to add new functions to an existing class without inheriting from it or modifying its source code. They are resolved statically at compile time. They are useful for adding utility functions to framework classes or your own classes to create cleaner, more readable APIs.

Example: `fun String.addExclamation(): String { return “$this!” }`

Both create read-only properties.

• `val` (value): A runtime constant. Its value can be determined at runtime (e.g., by a function call) but cannot be changed after initialization.
• `const val` (compile-time constant): Its value must be known at compile time. It can only be used for primitive types and Strings, and must be declared at the top level or as a member of an `object`. The value is inlined by the compiler.

A `typealias` provides an alternative name for an existing type. They are useful for shortening long generic types or for giving a more descriptive domain-specific name to a type. For example, `typealias UserId = String` or `typealias UserData = Map>`. This does not create a new type; it’s purely a synonym.

Starting with Spring Boot 2.2, controllers can have `suspend` functions. Spring MVC will automatically manage the coroutine context and thread handling. When a `suspend` controller function is called, it executes on the default servlet thread pool but will suspend without blocking the thread during async operations. This allows a small number of threads to handle many concurrent requests efficiently.

Ktor’s request processing is built on a **pipeline** system. A pipeline consists of a sequence of phases, and you can install “interceptors” into these phases to process a request. For example, the `ApplicationCallPipeline` has phases like `Setup`, `Monitoring`, `Features`, `Call`, and `Fallback`.

A **Feature** (or Plugin) is a reusable component that installs interceptors into the pipeline to add functionality like authentication, serialization, or logging. This makes Ktor highly modular and configurable.

You can use a `data class` annotated with `@ConfigurationProperties`. The properties of the data class are mapped to external configuration keys. You enable this by annotating a configuration class with `@EnableConfigurationProperties(YourDataClass::class)`. This approach is type-safe, immutable by default, and provides excellent IDE support.

`kotlinx.serialization` is a modern, multiplatform serialization library developed by JetBrains. You might prefer it because:

• Kotlin-first: It’s designed specifically for Kotlin and seamlessly supports all its features like data classes, null safety, and default values.
• Multiplatform: It can be used in Kotlin/JVM, Kotlin/JS, and Kotlin/Native projects.
• Compile-time safety: It uses a compiler plugin to generate serializers, which provides better performance and catches errors at compile time rather than runtime. Jackson relies heavily on runtime reflection.

Exposed handles transactions with a `transaction` block. All database statements within this block are executed inside a single JDBC transaction. The `transaction` block takes an optional `db` parameter to specify the database and can be configured with isolation levels. If an exception is thrown inside the block, the transaction is automatically rolled back.

Kotlin’s features make it excellent for building DSLs. The key ingredients are:

1. Higher-Order Functions: Use functions that take lambdas as arguments.
2. Lambdas with Receivers: This allows the lambda to be called in the context of a specific “receiver” object, making its methods and properties available implicitly (e.g., the `apply` function).
3. Extension Functions: To add builder-style methods to existing classes.
4. `@DslMarker` annotation: To control the scope of receivers and prevent calling methods from an outer scope implicitly, which enhances type safety.

A robust strategy often avoids relying solely on exceptions for control flow. Instead, you can use a `Result` type (either from a library like `Result4k` or your own sealed class implementation: `sealed class Result`). This makes potential failures explicit in the function signature. The `Result` would have two subtypes, `Success(val data: T)` and `Failure(val error: Throwable)`. This forces callers to handle both success and failure paths explicitly, often using a `when` expression, leading to more resilient code.

Data classes are primarily designed for holding data. By declaring their properties with `val`, you make them read-only, promoting immutability. Data classes also automatically generate a `copy()` method. This makes it easy to create a modified copy of an object rather than mutating it in place, which is a core tenet of functional programming and helps avoid side effects in concurrent code.

• Readability & Conciseness: Higher-order functions like `map`, `filter`, and `fold` can express complex data transformations clearly.
• Fewer Bugs: Emphasizing pure functions and immutable data structures reduces side effects, making code easier to reason about and less prone to concurrency issues.
• Testability: Pure functions are easy to test as their output depends only on their input.
• Composability: Small, pure functions can be easily combined to build more complex logic.

The `object` keyword can be used in several ways:

• Object Declaration (Singleton): `object MySingleton` creates a thread-safe singleton instance.
• Companion Object: `companion object` inside a class creates a singleton object tied to that class, which is the idiomatic way to create factory methods or properties that are common to all instances (similar to Java’s `static`).
• Object Expression (Anonymous Class): `object : MyInterface { … }` creates a one-off anonymous instance of a class or interface.

The `kotlinx-coroutines-test` library is essential. It provides:

• `runTest` builder: Runs the test in a special `TestScope` that gives you control over the virtual time of the coroutine dispatcher.
• Virtual Time Control: Inside `runTest`, calls to `delay` do not actually wait in real-time. Instead, they advance a virtual clock. This allows tests with long delays to complete almost instantly. You can manually advance time with functions like `advanceTimeBy()`.

This is a common challenge when using mocking frameworks from the Java ecosystem like Mockito. There are a few solutions:

1. Use MockK: A mocking library built specifically for Kotlin. It can mock final classes and objects without any extra configuration.
2. Use the Mockito-inline plugin: This Mockito extension can mock final classes and methods.
3. Compiler Plugin (`all-open`): For frameworks like Spring that rely on proxies, Kotlin provides a compiler plugin that can automatically `open` classes annotated with specific annotations (e.g., `@Component`).

Property-based testing is a method where you define properties or invariants about your code that should hold true for any valid input. The testing framework then generates hundreds of random inputs to try and find a counterexample that falsifies the property. It’s great for finding edge cases that you might not think of yourself. In Kotlin, this can be implemented with libraries like **Kotest** or **junit-quickcheck**.

When you define a method or property inside a `companion object`, it is not truly static from Java’s perspective. You have to access it through the `Companion` instance (e.g., `MyClass.Companion.myMethod()`).

The `@JvmStatic` annotation tells the Kotlin compiler to also generate a true `static` method or field in the class’s bytecode. This allows for cleaner interoperability, letting you call it from Java with the familiar static syntax: `MyClass.myMethod()`.

• `==` (Structural Equality): This operator checks for equality by calling the `equals()` method. For data classes, it compares the values of all properties.
• `===` (Referential Equality): This operator checks if two references point to the exact same object in memory.

A backing property is a pattern used to expose a read-only version of a mutable property. You declare a private mutable property (e.g., `private val _items = mutableListOf()`) and a public read-only property of the same type (e.g., `val items: List = _items`) that exposes the private property. This allows the class to modify the state internally while preventing external code from doing so, enforcing better encapsulation.