Kotlin

Kotlin

What I do

I am a modern, statically-typed programming language developed by JetBrains, first released in 2011. I run on the JVM, Android, and JavaScript (Kotlin/JS), providing full interoperability with existing Java codebases. I offer concise syntax, null safety, extension functions, data classes, coroutines for asynchronous programming, and smart type inference. I am the officially supported language for Android development and widely used for backend development with Ktor, Spring Boot, and other frameworks.

When to use me

Use Kotlin when building Android applications, backend APIs with Ktor/Spring Boot, multi-platform applications (JVM, JS, Native), when you need Java interoperability with modern language features, or when building applications with coroutine-based concurrency.

Core Concepts

• Null Safety: Types are non-nullable by default, nullable types use ? suffix, safe calls with ?., Elvis operator ?:
• Data Classes: Classes with automatically generated equals, hashCode, toString, and copy methods.
• Extension Functions: Add methods to existing classes without modifying source code or inheritance.
• Lambda Expressions: Concise syntax for anonymous functions, used extensively in collections.
• Smart Casts: Type checks automatically cast within conditional blocks.
• Sealed Classes: Restricted class hierarchies for representing restricted type hierarchies.
• Coroutines: Asynchronous programming with suspend functions, async/await patterns.
• Delegation: Composition over inheritance with by keyword for property delegation.
• Type Inference: Compiler infers types in most situations, reducing verbosity.
• Interoperability: 100% interoperable with Java, can call Java code and vice versa.

Code Examples

Null Safety and Smart Casts:

fun main() {
    val name: String? = null
    val length: Int = name?.length ?: 0
    println("Length: $length")
    
    val items: List<String?> = listOf("hello", null, "world")
    
    items.forEach { item ->
        item?.let {
            println("Item: ${it.uppercase()}")
        }
    }
    
    val result = items.mapNotNull { it?.uppercase() }
    println("Result: $result")
    
    fun printLength(str: String?) {
        if (str != null) {
            println("Length: ${str.length}")  // Smart cast to String
        } else {
            println("String is null")
        }
    }
    
    printLength("Kotlin")
    printLength(null)
    
    val value: Any = "Hello"
    if (value is String) {
        println("Length: ${value.length}")  // Smart cast
    }
    
    val message: String? = null
    val nonNullMessage: String = message ?: throw IllegalArgumentException("Message required")
    println("Message: $nonNullMessage")
}

Data Classes and Destructuring:

data class User(
    val id: Long,
    val name: String,
    val email: String,
    val age: Int = 0
)

fun main() {
    val user = User(1, "Alice", "alice@example.com", 30)
    
    println(user)
    println("Name: ${user.name}")
    println("Copy with new email: ${user.copy(email = "new@example.com")}")
    
    val (id, name, email, age) = user
    println("Destructured: $id, $name, $email, $age")
    
    val users = listOf(
        User(1, "Alice", "alice@example.com", 30),
        User(2, "Bob", "bob@example.com", 25),
        User(3, "Charlie", "charlie@example.com", 35)
    )
    
    users.forEach { (id, name) ->
        println("User $id: $name")
    }
    
    val updatedUsers = users.map { it.copy(age = it.age + 1) }
    val sortedByAge = users.sortedByDescending { it.age }
    val groupedByAge = users.groupBy { it.age / 10 * 10 }
    
    println("Grouped: $groupedByAge")
    
    data class Point(val x: Int, val y: Int)
    
    operator fun Point.plus(other: Point) = Point(x + other.x, y + other.y)
    val p1 = Point(1, 2)
    val p2 = Point(3, 4)
    val p3 = p1 + p2
    println("Point: $p3")
}

Coroutines and Async Programming:

import kotlinx.coroutines.*
import kotlin.system.measureTimeMillis

suspend fun fetchData(id: Int): String {
    delay(100)
    return "Data for $id"
}

suspend fun fetchMultiple(ids: List<Int>): List<String> = coroutineScope {
    ids.map { id ->
        async { fetchData(id) }
    }.awaitAll()
}

fun main() = runBlocking {
    val time = measureTimeMillis {
        val result = fetchMultiple(listOf(1, 2, 3, 4, 5))
        println("Result: $result")
    }
    println("Time: ${time}ms")
    
    launch {
        for (i in 1..5) {
            delay(100)
            println("Coroutine: $i")
        }
    }
    
    val job = launch {
        try {
            repeat(10) { i ->
                delay(50)
                if (i == 3) throw CancellationException()
                println("Task: $i")
            }
        } finally {
            println("Cleanup")
        }
    }
    
    job.join()
    
    withTimeoutOrNull(200) {
        repeat(10) { i ->
            delay(30)
            println("Timeout task: $i")
        }
    } ?: println("Timed out")
    
    val asyncResult = async {
        delay(100)
        "Async result"
    }
    println("Result: ${asyncResult.await()}")
}

Extension Functions and Interfaces:

fun String.uppercaseFirst(): String {
    return if (isNotEmpty()) {
        this[0].uppercaseChar().toString() + substring(1)
    } else {
        this
    }
}

fun <T> List<T>.second(): T? = getOrNull(1)

fun Int.isEven(): Boolean = this % 2 == 0

fun ClosedRange<Int>.random(): Int = (this.first..this.last).random()

interface Logger {
    fun log(message: String)
}

class ConsoleLogger : Logger {
    override fun log(message: String) {
        println("[${java.time.LocalDateTime.now()}] $message")
    }
}

class User(
    val id: Long,
    val name: String
) {
    private val logger: Logger by lazy { ConsoleLogger() }
    
    fun save() {
        logger.log("Saving user $id")
    }
}

interface Repository<T> {
    fun findById(id: Long): T?
    fun save(entity: T): T
}

class InMemoryRepository<T : HasId> : Repository<T> {
    private val map = mutableMapOf<Long, T>()
    
    override fun findById(id: Long): T? = map[id]
    
    override fun save(entity: T): T {
        map[entity.id] = entity
        return entity
    }
}

interface HasId {
    val id: Long
}

fun main() {
    println("hello".uppercaseFirst())
    println(listOf(1, 2, 3).second())
    println(4.isEven())
    println((1..10).random())
    
    val user = User(1, "Alice")
    user.save()
}

Best Practices

1. Use val by Default: Use val for immutable properties, var only when reassignment is necessary.
2. Prefer Data Classes Over Lombok: Use Kotlin data classes instead of Lombok annotations for cleaner code.
3. Use Extension Functions Wisely: Use extensions to add utility methods without modifying original classes.
4. Leverage Default Arguments: Use default arguments instead of function overloads.
5. Use Coroutines for Async: Prefer coroutines and suspend functions over callbacks and threads.
6. Use sealed Classes for State: Use sealed classes to represent UI states or state machines.
7. Use lateinit for late Initialization: Use lateinit for properties initialized after construction.
8. Prefer apply/let/run: Use appropriate scope functions (apply, let, run, with, also) for cleaner code.
9. Use Type Aliases for Readability: Create type aliases for frequently used function types.
10. Write Tests with JUnit 5/Kotest: Use JUnit 5 or Kotest for unit and property-based testing.