Exception Handling, Nullability Strategy, and Result Patterns
Write more reliable Kotlin by learning how to handle errors thoughtfully instead of scattering unsafe assumptions across the codebase.
Inside this chapter
- Errors in Real Systems
- Try, Catch, and Finally
- Fail Fast vs Recover Gracefully
- Result-Like Modeling
- Avoiding the Double-Bang Trap
- Operational Example
Series navigation
Study the chapters in order for the clearest path from Kotlin setup and syntax to coroutines, backend work, clean design, multiplatform thinking, and advanced engineering practice. Use the navigation at the bottom to move smoothly through the full tutorial series.
Errors in Real Systems
Software does not fail only because of bad logic. It fails because of slow networks, invalid payloads, missing database rows, permission denial, misconfiguration, disk issues, and user behavior. Error handling is therefore a central engineering skill.
Try, Catch, and Finally
try {
val number = "42".toInt()
println(number)
} catch (ex: NumberFormatException) {
println("Invalid number")
} finally {
println("Done")
}Students should understand where explicit exceptions are helpful and where they may create noisy control flow.
Fail Fast vs Recover Gracefully
Some errors should stop execution quickly because continuing would corrupt data. Others should be transformed into user-facing validation or retry paths. Strong engineers decide which category applies instead of handling every error the same way.
Result-Like Modeling
sealed class ApiResult<out T> {
data class Success<T>(val data: T) : ApiResult<T>()
data class Failure(val message: String) : ApiResult<Nothing>()
}This pattern is common when teams want explicit success and failure modeling instead of relying only on exceptions.
Avoiding the Double-Bang Trap
The !! operator forces a nullable value to become non-null and throws an exception if it is actually null. It should be used very carefully. Overusing it defeats much of Kotlin’s safety advantage.
Operational Example
An inventory service may parse supplier feeds, validate data, and return structured failure states when SKU or pricing information is malformed. Good error modeling helps operators fix the right thing quickly and prevents hidden data corruption.