Best Practices & Next Steps

Introduction

You've covered Kotlin's core language features — from null safety to coroutines. This final lesson ties everything together with the idioms and conventions that separate code that merely compiles from code that reads as genuinely idiomatic Kotlin, plus a look at where the ecosystem goes from here.

You'll cover official coding conventions, the five "scope functions" that appear constantly in real Kotlin code, a short complete example putting several lessons together, the frameworks worth knowing next, and recommended next steps.

Coding Conventions

JetBrains publishes official Kotlin coding conventions at kotlinlang.org, and most tooling (including IntelliJ's default formatter) follows them out of the box.

Scope Functions: let, apply, run, also, with

Kotlin's standard library defines five closely related "scope functions" that execute a block of code in the context of an object. They look similar but differ in two ways: whether they refer to the object as `it` or `this` inside the block, and what they return.

data class Config(var host: String = "", var port: Int = 0)

fun main() {
    // let: run code on a non-null value, return a transformed result
    val length = "Kotlin".let { it.length }
    println(length)

    // apply: configure an object's properties, return the object itself
    val config = Config().apply {
        host = "localhost"
        port = 8080
    }
    println(config)

    // also: perform a side effect (like logging), return the object unchanged
    val numbers = listOf(1, 2, 3).also { println("Created list: $it") }
    println(numbers)
}

A common, practical rule of thumb: use `let` with a safe call (`value?.let { ... }`) to run code only when a nullable value isn't null; use `apply` to configure an object's properties right after construction; use `also` for side effects like logging that shouldn't change what gets returned.

Writing Idiomatic Kotlin

Beyond individual features, idiomatic Kotlin has a recognizable style: it favors immutability (`val` over `var`), expressions over statements (`if`/`when` returning values), null safety operators over defensive null checks scattered everywhere, and data/sealed classes over hand-written boilerplate.

Popular Kotlin Frameworks

Once you're comfortable with the language itself, these are the ecosystems where Kotlin is most widely used in production.

A Complete Example

Here is a small program that ties together data classes, null safety, collections, and a when expression — several of the topics from this course working together.

data class Product(val name: String, val price: Double, val stock: Int)

fun describeStock(product: Product): String = when {
    product.stock == 0 -> "${product.name} is out of stock"
    product.stock < 5 -> "${product.name} is low on stock (${product.stock} left)"
    else -> "${product.name} is well stocked"
}

fun findCheapest(products: List<Product>): Product? =
    products.minByOrNull { it.price }

fun main() {
    val products = listOf(
        Product("Keyboard", 49.99, 12),
        Product("Mouse", 19.99, 0),
        Product("Monitor", 199.99, 3)
    )

    products.forEach { println(describeStock(it)) }

    val cheapest = findCheapest(products)
    println("Cheapest: ${cheapest?.name ?: "No products found"}")
}

Where to Go Next

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Across this course, you've gone from "Hello, Kotlin!" through null safety, classes, collections, data and sealed classes, and coroutines — the core toolkit for writing real Kotlin programs. From here, the best next step is to build something real: a small Android app, a backend API, or a multiplatform project, applying everything you've learned along the way.