Intermediate
Vocabulary
#kotlin
#android
#coroutines
#null-safety
Kotlin Vocabulary
5 exercises — null safety operators, data classes, sealed classes, scope functions (let/apply/also), and coroutines (suspend, Dispatchers).
0 / 30 completed
1 / 30
A Kotlin developer explains: "Kotlin's null safety system forces you to choose between a nullable and non-nullable type at compile time." What do the operators
?, ?., ?:, and !! each do?Kotlin null safety operators — the full vocabulary:
Adding
Without
Replaces the Java null-check pattern.
Chainable:
Named after the Elvis hairstyle (?:)
Use only when you have external proof of non-nullability (e.g., a validated variable that the type system cannot track).
Related vocabulary:
• NullPointerException (NPE) — the runtime error Kotlin's type system is designed to prevent
• smart cast — after a null check, Kotlin automatically casts to the non-nullable type
• let —
• lateinit var — declare a non-null var that will be initialised later (before first use)
String? — nullable type declarationAdding
? to a type makes it nullable: val name: String? can hold a String or null.Without
?, the type is non-nullable — the compiler guarantees it is never null.?. — safe call operatorname?.length → returns null if name is null, otherwise evaluates name.length.Replaces the Java null-check pattern.
Chainable:
user?.address?.city?: — Elvis operatorval len = name?.length ?: 0 → if the left side is null, use the right side as the default.Named after the Elvis hairstyle (?:)
!! — non-null assertion operatorname!! → tells the compiler "I guarantee this is not null." If it IS null at runtime, throws NullPointerException.Use only when you have external proof of non-nullability (e.g., a validated variable that the type system cannot track).
Related vocabulary:
• NullPointerException (NPE) — the runtime error Kotlin's type system is designed to prevent
• smart cast — after a null check, Kotlin automatically casts to the non-nullable type
• let —
name?.let { println(it) } — run a block only if non-null• lateinit var — declare a non-null var that will be initialised later (before first use)
2 / 30
In a code review, a senior developer comments: "Use a data class here instead of a regular class — you get equals/hashCode/copy/toString for free." What does this mean in Kotlin?
Kotlin data class vocabulary:
Declared with
Auto-generated functions:
•
•
•
•
•
Restrictions on data classes:
• Cannot be
• At least one property in the primary constructor
• Properties in primary constructor are used for equals/hashCode; body properties are not
When to use a data class:
• DTOs (Data Transfer Objects) — mapping API responses
• Value objects in domain-driven design
• State representation (e.g., UI state in Android)
Regular class vs data class:
A regular class does NOT auto-generate these functions — equals compares by reference. Two objects with identical properties are not equal unless you manually override equals().
Vocabulary:
• structural equality (
• referential equality (
• destructuring declaration —
Declared with
data class User(val id: Int, val name: String)Auto-generated functions:
•
equals() — compares by structural equality (property values), not reference•
hashCode() — consistent with equals; suitable for use as map keys or in sets•
toString() → "User(id=1, name=Alice)" — human-readable output in logs•
copy() — create a modified copy: user.copy(name = "Bob") keeps all other fields intact•
componentN() — enables destructuring: val (id, name) = userRestrictions on data classes:
• Cannot be
abstract, open, or sealed• At least one property in the primary constructor
• Properties in primary constructor are used for equals/hashCode; body properties are not
When to use a data class:
• DTOs (Data Transfer Objects) — mapping API responses
• Value objects in domain-driven design
• State representation (e.g., UI state in Android)
Regular class vs data class:
A regular class does NOT auto-generate these functions — equals compares by reference. Two objects with identical properties are not equal unless you manually override equals().
Vocabulary:
• structural equality (
== in Kotlin) — compares property values• referential equality (
=== in Kotlin) — compares object identity (same memory address)• destructuring declaration —
val (a, b) = pair3 / 30
An architect says: "Model your domain states as a sealed class — it gives you exhaustive
when expressions." What is a sealed class and what does "exhaustive" mean here?Sealed classes and exhaustive when expressions:
Sealed class definition:
A sealed class restricts the type hierarchy — all direct subclasses must be in the same package (Kotlin 1.5+: same package/module). This gives the compiler complete knowledge of all possible subtypes.
Exhaustive when:
Because the compiler knows all subclasses, a
Sealed class vs enum:
• enum — each case has the same type; no per-case properties different from others
• sealed class — each subclass can have its own properties and methods; much more flexible
Use cases:
• UI state: Loading / Success / Error
• Network result: Success / NetworkError / Timeout / Unauthorised
• Domain events: UserLoggedIn / UserLoggedOut / PasswordChanged
Kotlin 1.5+ sealed interface:
Sealed class definition:
A sealed class restricts the type hierarchy — all direct subclasses must be in the same package (Kotlin 1.5+: same package/module). This gives the compiler complete knowledge of all possible subtypes.
sealed class UiState {
object Loading : UiState()
data class Success(val data: List<Item>) : UiState()
data class Error(val message: String) : UiState()
}Exhaustive when:
Because the compiler knows all subclasses, a
when expression used as a statement does not require else — it warns (or errors) if you miss a branch. When used as an expression (returning a value), it is required to be exhaustive.when (state) {
is UiState.Loading -> showSpinner()
is UiState.Success -> showData(state.data)
is UiState.Error -> showError(state.message)
// No else needed — compiler verifies all cases
}Sealed class vs enum:
• enum — each case has the same type; no per-case properties different from others
• sealed class — each subclass can have its own properties and methods; much more flexible
Use cases:
• UI state: Loading / Success / Error
• Network result: Success / NetworkError / Timeout / Unauthorised
• Domain events: UserLoggedIn / UserLoggedOut / PasswordChanged
Kotlin 1.5+ sealed interface:
sealed interface Result — same exhaustiveness, but allows implementing multiple interfaces.4 / 30
A Kotlin code review mentions: "Use scope functions —
let and apply are very different." What is the core difference between let, run, apply, also, and with?Kotlin scope functions — the complete vocabulary:
All five scope functions run a block on an object but differ on two axes:
Most common patterns:
•
•
•
Mnemonic:
•
•
All five scope functions run a block on an object but differ on two axes:
| Function | Context as | Returns | Primary use |
|---|---|---|---|
let | it | lambda result | null-safe chain; transform |
run | this | lambda result | object config + compute result |
apply | this | context object | builder pattern; object init |
also | it | context object | side effects (logging) |
with | this | lambda result | non-extension; group operations |
Most common patterns:
•
user?.let { sendEmail(it) } — run block only if non-null•
TextView(context).apply { text = "Hello"; textSize = 16f } — builder init•
list.also { log(it) }.map { transform(it) } — side effect in a chainMnemonic:
•
apply and also return the context object — so they sit in the middle of a chain•
let, run, with return the lambda result — use them at the end of a chain or to compute a value5 / 30
A Kotlin backend PR description says: "Moved the database call to a suspend function running on
Dispatchers.IO to avoid blocking the main coroutine." What do these terms mean?Kotlin coroutines vocabulary:
Coroutine
A coroutine is a concurrency primitive that can be suspended (paused) and resumed without blocking a thread. Unlike threads, thousands of coroutines can run on a small number of OS threads.
suspend function
A function marked with
Dispatchers — the coroutine scheduler vocabulary:
•
•
•
•
launch vs async:
•
•
Structured concurrency:
Coroutines follow a parent-child hierarchy via
Coroutine
A coroutine is a concurrency primitive that can be suspended (paused) and resumed without blocking a thread. Unlike threads, thousands of coroutines can run on a small number of OS threads.
suspend function
A function marked with
suspend can be paused at suspension points (e.g., delay(), withContext(), database calls) and resumed later. It can only be called from within another suspend function or a coroutine scope.suspend fun fetchUser(id: Int): User {
return withContext(Dispatchers.IO) {
database.getUser(id) // blocking call, runs on IO thread pool
}
}Dispatchers — the coroutine scheduler vocabulary:
•
Dispatchers.Main — Android UI thread; also used for lightweight suspend operations•
Dispatchers.IO — thread pool for blocking I/O (database, network, file system); up to 64 threads (or CPU count, whichever is higher)•
Dispatchers.Default — CPU-intensive work (sorting, JSON parsing); thread count = CPU cores•
Dispatchers.Unconfined — not confined to any thread; use rarelylaunch vs async:
•
launch { } — fire-and-forget; returns a Job; does not return a value•
async { } — returns a Deferred<T>; call .await() to get the result (like Future/Promise)Structured concurrency:
Coroutines follow a parent-child hierarchy via
CoroutineScope. When a scope is cancelled, all child coroutines are cancelled too — preventing goroutine-style leaks.6 / 30
Alex: "I'm getting a `NullPointerException` when trying to access the `name` property of this user object. I've checked for null before accessing it, but it still happens!" What is the most likely reason for this persistent issue?NullPointerExceptions occur when you attempt to access a property or method on an object that has not been initialized or has a null value. Even if you've explicitly checked for `null` using the `?.` operator, there could be scenarios where the data source unexpectedly returns a null value at runtime, bypassing your intended protection. The problem lies in the data itself, not necessarily the code's logic.
7 / 30
Sarah (in a Slack channel) asks: "Why do I need to use `synchronized` blocks when working with concurrent collections in Kotlin? It seems like adding multiple threads accessing the same collection is inherently safe."While Kotlin's coroutines offer excellent concurrency features, directly manipulating shared mutable data structures like collections can still lead to race conditions and data corruption if not handled carefully. `synchronized` blocks provide a mechanism for mutual exclusion, ensuring that only one thread at a time can access the collection, thereby preventing these issues and guaranteeing atomicity – meaning operations are completed as a single, indivisible unit.
8 / 30
Ben (in a PR description) writes: "Implemented the `calculateTotal` function using `fold`. This allows us to accumulate the price of each item into a single total value in a concise and functional way."The `fold` function (also known as `reduce`) is a powerful higher-order function in Kotlin that allows you to accumulate values from a collection by applying a binary operation to each element and an initial value. It effectively reduces the collection into a single result, making it useful for tasks like summing numbers, concatenating strings, or performing more complex calculations – all without needing to manually manage mutable variables.
9 / 30
David (during a standup) states: "I'm using `with` in this function to simplify the code. It lets me pass in the context and use it within the block without explicitly declaring variables."The `with` function in Kotlin is designed to provide a more concise way to execute a block of code within the scope of another object. It essentially allows you to pass in an object's context (its members) and use them directly within the block without needing to explicitly declare variables for each one. This reduces boilerplate and improves readability, especially when working with objects that have many properties.
10 / 30
Emily: "I'm using a CoroutineScope to manage my coroutines. I need to ensure all the coroutines spawned within this scope are cancelled when the scope is completed."The `Job` class is central to managing coroutine lifecycle and cancellation within Kotlin. When you create a `Job` associated with a CoroutineScope, the `Job` represents the execution of all coroutines spawned from that scope. Calling `cancel()` on the `Job` effectively signals all child coroutines to stop their work, ensuring they are terminated cleanly when the scope completes – this is a crucial aspect of preventing resource leaks and maintaining program stability.
11 / 30
Alex: "I'm getting a `NullPointerException` when trying to access the `name` property of this user object. I've checked for null before accessing it, but it still happens!" What is the most likely reason for this persistent issue?NullPointerExceptions occur when you attempt to access a property or method on an object that has not been initialized or has a null value. Even if you've explicitly checked for `null` using the `?.` operator, there could be scenarios where the data source unexpectedly returns a null value at runtime, bypassing your intended protection. The problem lies in the data itself, not necessarily the code's logic.
12 / 30
Sarah (in a Slack channel) asks: "Why do I need to use `synchronized` blocks when working with concurrent collections in Kotlin? It seems like adding multiple threads accessing the same collection is inherently safe."While Kotlin's coroutines offer excellent concurrency features, directly manipulating shared mutable data structures like collections can still lead to race conditions and data corruption if not handled carefully. `synchronized` blocks provide a mechanism for mutual exclusion, ensuring that only one thread at a time can access the collection, thereby preventing these issues and guaranteeing atomicity – meaning operations are completed as a single, indivisible unit.
13 / 30
Ben (in a PR description) writes: "Implemented the `calculateTotal` function using `fold`. This allows us to accumulate the price of each item into a single total value in a concise and functional way."The `fold` function (also known as `reduce`) is a powerful higher-order function in Kotlin that allows you to accumulate values from a collection by applying a binary operation to each element and an initial value. It effectively reduces the collection into a single result, making it useful for tasks like summing numbers, concatenating strings, or performing more complex calculations – all without needing to manually manage mutable variables.
14 / 30
David (during a standup) states: "I'm using `with` in this function to simplify the code. It lets me pass in the context and use it within the block without explicitly declaring variables."The `with` function in Kotlin is designed to provide a more concise way to execute a block of code within the scope of another object. It essentially allows you to pass in an object's context (its members) and use them directly within the block without needing to explicitly declare variables for each one. This reduces boilerplate and improves readability, especially when working with objects that have many properties.
15 / 30
Emily: "I'm using a CoroutineScope to manage my coroutines. I need to ensure all the coroutines spawned within this scope are cancelled when the scope is completed."The `Job` class is central to managing coroutine lifecycle and cancellation within Kotlin. When you create a `Job` associated with a CoroutineScope, the `Job` represents the execution of all coroutines spawned from that scope. Calling `cancel()` on the `Job` effectively signals all child coroutines to stop their work, ensuring they are terminated cleanly when the scope completes – this is a crucial aspect of preventing resource leaks and maintaining program stability.
16 / 30
Alex: "I'm getting a `NullPointerException` when trying to access the `name` property of this user object. I've checked for null before accessing it, but it still happens!" What is the most likely reason for this persistent issue?NullPointerExceptions occur when you attempt to access a property or method on an object that has not been initialized or has a null value. Even if you've explicitly checked for `null` using the `?.` operator, there could be scenarios where the data source unexpectedly returns a null value at runtime, bypassing your intended protection. The problem lies in the data itself, not necessarily the code's logic.
17 / 30
Sarah (in a Slack channel) asks: "Why do I need to use `synchronized` blocks when working with concurrent collections in Kotlin? It seems like adding multiple threads accessing the same collection is inherently safe."While Kotlin's coroutines offer excellent concurrency features, directly manipulating shared mutable data structures like collections can still lead to race conditions and data corruption if not handled carefully. `synchronized` blocks provide a mechanism for mutual exclusion, ensuring that only one thread at a time can access the collection, thereby preventing these issues and guaranteeing atomicity – meaning operations are completed as a single, indivisible unit.
18 / 30
Ben (in a PR description) writes: "Implemented the `calculateTotal` function using `fold`. This allows us to accumulate the price of each item into a single total value in a concise and functional way."The `fold` function (also known as `reduce`) is a powerful higher-order function in Kotlin that allows you to accumulate values from a collection by applying a binary operation to each element and an initial value. It effectively reduces the collection into a single result, making it useful for tasks like summing numbers, concatenating strings, or performing more complex calculations – all without needing to manually manage mutable variables.
19 / 30
David (during a standup) states: "I'm using `with` in this function to simplify the code. It lets me pass in the context and use it within the block without explicitly declaring variables."The `with` function in Kotlin is designed to provide a more concise way to execute a block of code within the scope of another object. It essentially allows you to pass in an object's context (its members) and use them directly within the block without needing to explicitly declare variables for each one. This reduces boilerplate and improves readability, especially when working with objects that have many properties.
20 / 30
Emily: "I'm using a CoroutineScope to manage my coroutines. I need to ensure all the coroutines spawned within this scope are cancelled when the scope is completed."The `Job` class is central to managing coroutine lifecycle and cancellation within Kotlin. When you create a `Job` associated with a CoroutineScope, the `Job` represents the execution of all coroutines spawned from that scope. Calling `cancel()` on the `Job` effectively signals all child coroutines to stop their work, ensuring they are terminated cleanly when the scope completes – this is a crucial aspect of preventing resource leaks and maintaining program stability.
21 / 30
Alex: "I'm getting a `NullPointerException` when trying to access the `name` property of this user object. I've checked for null before accessing it, but it still happens!" What is the most likely reason for this persistent issue?NullPointerExceptions occur when you attempt to access a property or method on an object that has not been initialized or has a null value. Even if you've explicitly checked for `null` using the `?.` operator, there could be scenarios where the data source unexpectedly returns a null value at runtime, bypassing your intended protection. The problem lies in the data itself, not necessarily the code's logic.
22 / 30
Sarah (in a Slack channel) asks: "Why do I need to use `synchronized` blocks when working with concurrent collections in Kotlin? It seems like adding multiple threads accessing the same collection is inherently safe."While Kotlin's coroutines offer excellent concurrency features, directly manipulating shared mutable data structures like collections can still lead to race conditions and data corruption if not handled carefully. `synchronized` blocks provide a mechanism for mutual exclusion, ensuring that only one thread at a time can access the collection, thereby preventing these issues and guaranteeing atomicity – meaning operations are completed as a single, indivisible unit.
23 / 30
Ben (in a PR description) writes: "Implemented the `calculateTotal` function using `fold`. This allows us to accumulate the price of each item into a single total value in a concise and functional way."The `fold` function (also known as `reduce`) is a powerful higher-order function in Kotlin that allows you to accumulate values from a collection by applying a binary operation to each element and an initial value. It effectively reduces the collection into a single result, making it useful for tasks like summing numbers, concatenating strings, or performing more complex calculations – all without needing to manually manage mutable variables.
24 / 30
David (during a standup) states: "I'm using `with` in this function to simplify the code. It lets me pass in the context and use it within the block without explicitly declaring variables."The `with` function in Kotlin is designed to provide a more concise way to execute a block of code within the scope of another object. It essentially allows you to pass in an object's context (its members) and use them directly within the block without needing to explicitly declare variables for each one. This reduces boilerplate and improves readability, especially when working with objects that have many properties.
25 / 30
Emily: "I'm using a CoroutineScope to manage my coroutines. I need to ensure all the coroutines spawned within this scope are cancelled when the scope is completed."The `Job` class is central to managing coroutine lifecycle and cancellation within Kotlin. When you create a `Job` associated with a CoroutineScope, the `Job` represents the execution of all coroutines spawned from that scope. Calling `cancel()` on the `Job` effectively signals all child coroutines to stop their work, ensuring they are terminated cleanly when the scope completes – this is a crucial aspect of preventing resource leaks and maintaining program stability.
26 / 30
Alex: "I'm getting a `NullPointerException` when trying to access the `name` property of this user object. I've checked for null before accessing it, but it still happens!" What is the most likely reason for this persistent issue?NullPointerExceptions occur when you attempt to access a property or method on an object that has not been initialized or has a null value. Even if you've explicitly checked for `null` using the `?.` operator, there could be scenarios where the data source unexpectedly returns a null value at runtime, bypassing your intended protection. The problem lies in the data itself, not necessarily the code's logic.
27 / 30
Sarah (in a Slack channel) asks: "Why do I need to use `synchronized` blocks when working with concurrent collections in Kotlin? It seems like adding multiple threads accessing the same collection is inherently safe."While Kotlin's coroutines offer excellent concurrency features, directly manipulating shared mutable data structures like collections can still lead to race conditions and data corruption if not handled carefully. `synchronized` blocks provide a mechanism for mutual exclusion, ensuring that only one thread at a time can access the collection, thereby preventing these issues and guaranteeing atomicity – meaning operations are completed as a single, indivisible unit.
28 / 30
Ben (in a PR description) writes: "Implemented the `calculateTotal` function using `fold`. This allows us to accumulate the price of each item into a single total value in a concise and functional way."The `fold` function (also known as `reduce`) is a powerful higher-order function in Kotlin that allows you to accumulate values from a collection by applying a binary operation to each element and an initial value. It effectively reduces the collection into a single result, making it useful for tasks like summing numbers, concatenating strings, or performing more complex calculations – all without needing to manually manage mutable variables.
29 / 30
David (during a standup) states: "I'm using `with` in this function to simplify the code. It lets me pass in the context and use it within the block without explicitly declaring variables."The `with` function in Kotlin is designed to provide a more concise way to execute a block of code within the scope of another object. It essentially allows you to pass in an object's context (its members) and use them directly within the block without needing to explicitly declare variables for each one. This reduces boilerplate and improves readability, especially when working with objects that have many properties.
30 / 30
Emily: "I'm using a CoroutineScope to manage my coroutines. I need to ensure all the coroutines spawned within this scope are cancelled when the scope is completed."The `Job` class is central to managing coroutine lifecycle and cancellation within Kotlin. When you create a `Job` associated with a CoroutineScope, the `Job` represents the execution of all coroutines spawned from that scope. Calling `cancel()` on the `Job` effectively signals all child coroutines to stop their work, ensuring they are terminated cleanly when the scope completes – this is a crucial aspect of preventing resource leaks and maintaining program stability.
Frequently Asked Questions
What does the "Kotlin Vocabulary" vocabulary exercise cover?
This exercise tests real IT vocabulary related to kotlin vocabulary through 30 multiple-choice questions, each built from realistic workplace sentences rather than abstract definitions.
Is this vocabulary exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is completely free — no account, sign-up, or payment required.
How many questions does this exercise have?
This exercise has 30 questions. Each one shows a real-world sentence or scenario with multiple-choice options and an explanation once you answer.
What happens after I answer a question?
You'll see immediate feedback showing whether your answer was correct, along with a short explanation of why — then a button to move to the next question, and a full results screen at the end.
Can I retry the exercise if I get questions wrong?
Yes. Once you reach the results screen, click "Try again" to reset your answers and go through the exercise from the start as many times as you like.
Do I need to create an account to take this exercise?
No account is needed. Your answers are scored in your browser during the session — nothing is saved to a server, so you can jump straight in.
Is my progress saved if I leave the page?
No — progress within an exercise resets if you navigate away or reload. Each exercise is short enough to complete in a few minutes in one sitting.
Are these vocabulary exercises connected to other topics?
Yes — browse the full vocabulary exercises hub to find related modules covering adjacent IT topics and roles.
How is this different from reading a glossary or blog article?
Exercises like this one are active recall drills — you have to choose the correct term or phrasing yourself, which builds retention faster than passively reading a definition.
Where can I find more vocabulary exercises?
Browse the full Vocabulary exercises hub for hundreds of modules covering Agile, DevOps, security, databases, architecture, and more — organised by IT role and skill.