kotlin-expert

name	kotlin-expert
description	Kotlin development principles and decision-making. Modern Kotlin 2.0, coroutines, Ktor, Jetpack Compose, Android.

Kotlin Expert - Modern Kotlin 2.0+

Kotlin development principles and decision-making. Learn to THINK, not copy-paste patterns.

---

⚠️ How to Use This Skill

This skill teaches decision-making principles for Kotlin development.

• ASK user for platform (JVM, Android, Native, Multiplatform)
• Choose coroutines for async (NOT threads)
• Don't write Java in Kotlin

---

1. Platform Selection

Decision Tree

What are you building?
│
├── REST API (JVM)
│   ├── Ktor (lightweight, async-first)
│   ├── Spring Boot (enterprise, familiar)
│   ├── Javalin (simple, similar to Spark)
│   └── Vert.x (reactive, high-performance)
│
├── Android App
│   ├── Jetpack Compose (modern UI)
│   └── XML + View System (legacy)
│
├── Kotlin Multiplatform (KMP)
│   ├── Share logic Android/iOS/WASM
│   └── Kotlin/JS for web
│
├── Desktop
│   ├── Compose for Desktop (TornadoFX deprecated)
│   └── Compose for Mac/Linux/Windows
│
├── Backend Worker
│   ├── Kotlin Coroutines + Redis
│   └── Quarkus (reactive)
│
└── Scripting/Tools
    └── Kotlin Script (.kts) or jbang

Comparison Table

Factor	Ktor	Spring Boot	Javalin
Async	Native coroutines	Suspend functions	Native coroutines
Size	Lightweight	Full-stack	Very lightweight
Learning Curve	Low	Low	Very Low
Best For	Microservices	Enterprise apps	Simple APIs

---

2. Modern Kotlin Features (2.0+)

Data Classes & Records

// Data class (auto-generates equals, hashCode, toString, copy)
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Kotlin 1.9+ - Value classes (no allocation overhead)
@JvmInline
value class UserId(val value: Int)

// Kotlin 2.0 - Algebraic Data Types (sealed classes as exhausts)
sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
    data object Loading : Result<Nothing>()
}

fun handle(result: Result<User>) = when (result) {
    is Result.Success -> println("Got user: ${result.data.name}")
    is Result.Error -> println("Error: ${result.message}")
    Result.Loading -> println("Loading...")
    // Compiler knows this covers ALL cases!
}

Coroutines (NOT Threads)

// ❌ WRONG - Using threads in Kotlin
fun fetchUsers() = thread {
    val users = httpClient.get("/users")
    users.forEach { uiThread { display(it) } }
}

// ✅ CORRECT - Using coroutines
suspend fun fetchUsers(): List<User> = client.get("/users")

// Launching coroutines
viewModelScope.launch {
    val users = fetchUsers()  // Suspends, no blocking
    _uiState.value = UiState.Success(users)
}

// Flow for streaming (reactive streams)
fun userUpdates(): Flow<User> = database.userChanges()  // Creates flow
    .filter { it.isActive }
    .map { it.toDto() }
    .catch { emit(User.Guest) }

// Collecting flow
userUpdates()
    .onEach { /* update UI */ }
    .launchIn(viewModelScope)

Null Safety

// Nullable types (Kotlin's killer feature)
var name: String = "John"        // Non-null
var nullableName: String? = null // Nullable

// Safe calls - only access if not null
val length = name?.length        // Int? (might be null)

// Elvis operator - default if null
val len = name?.length ?: 0      // Int (never null)

// Not-null assertion (avoid unlesscertain)
val len2 = name!!.length        // Int (throws if null)

// Smart cast
if (user != null) {
    println(user.name)  // Smart cast to non-null
}

---

3. Dependency Injection

Koin (Lightweight)

// Define modules
val appModule = module {
    single { Database() }
    single { UserRepository(get()) }
    factory { GetUserUseCase(get()) }
}

// Start Koin
fun main() {
    startKoin {
        modules(appModule)
    }
}

// Inject
class UserService(private val repo: UserRepository)

Hilt (Android/JVM Standard)

// Define module
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    @Provides
    fun provideUserRepository(db: Database): UserRepository {
        return UserRepositoryImpl(db)
    }
}

// Inject in constructor
class UserService @Inject constructor(
    private val userRepository: UserRepository,
    private val emailService: EmailService
) { }

---

4. Ktor Framework

Minimal API

// Application
fun main() = runBlocking {
    embeddedServer(Netty, port = 8080) {
        routing {
            get("/users") {
                call.respond(UserService.getAll())
            }
            
            get("/users/{id}") {
                val id = call.parameters["id"]?.toInt()
                val user = UserService.getById(id)
                if (user != null) {
                    call.respond(user)
                } else {
                    call.respond(HttpStatusCode.NotFound)
                }
            }
            
            post("/users") {
                val user = call.receive<User>()
                val created = UserService.create(user)
                call.respond(HttpStatusCode.Created, created)
            }
        }
    }.waitWait()
}

With DI and Validations

// Install features
install(ContentNegotiation) {
    json()
}

install(Validation) {
    body<UserValidation>()
}

// API with error handling
routing {
    get("/users") {
        try {
            val users = userService.getAll()
            call.respond(users)
        } catch (e: Exception) {
            call.respond(HttpStatusCode.InternalServerError)
        }
    }
}

---

5. Database Patterns

Exposed (Kotlin SQL)

// Table definition
object Users : Table() {
    val id = integer("id").autoIncrement()
    val name = varchar("name", 50)
    val email = varchar("email", 100).uniqueIndex()
}

// DAO pattern
class UserDao {
    fun findById(id: Int): User? = db.query {
        Users.select { Users.id eq id }
            .map { it.toUser() }
            .singleOrNull()
    }
    
    fun findAll(): List<User> = db.query {
        Users.selectAll()
            .map { it.toUser() }
            .toList()
    }
}

Comparison

Library	Pros	Cons
Exposed	Kotlin-idiomatic, typesafe	Query DSL limited
Room	Android standard	Android only
Ktorm	Type-safe queries	Less maintained
JDBC/raw	Full control	Verbose

---

6. Testing Patterns

Kotest + MockK

// Behavior testing
class UserServiceTest : FreeSpec({
    val mockRepo = mockk<UserRepository>()
    val service = UserService(mockRepo)
    
    "getById" - {
        "returns user when found" {
            every { mockRepo.findById(1) } returns User(1, "[e-mail]")
            
            val result = service.getById(1)
            
            result.name shouldBe "[e-mail]"
        }
        
        "returns null when not found" {
            every { mockRepo.findById(99) } returns null
            
            val result = service.getById(99)
            
            result shouldBe null
        }
    }
})

Testing Tools

Tool	Purpose
Kotest	BDD-style testing
MockK	Mocking
Strikt	Assertions
InMemoryDB	Test databases
Kotest property-based	Property testing

---

7. Android Compose Patterns

State Management

@Composable
fun UserListScreen(
    viewModel: UserViewModel = koinViewModel()
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    
    when (val state = uiState) {
        is UiState.Loading -> CircularProgressIndicator()
        is UiState.Success -> UserList(state.users)
        is UiState.Error -> ErrorMessage(state.message)
    }
}

// ViewModel with StateFlow
class UserViewModel(
    private val getUsers: GetUsersUseCase
) : ViewModel() {
    
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
    
    init {
        loadUsers()
    }
    
    private fun loadUsers() = viewModelScope.launch {
        _uiState.value = UiState.Loading
        try {
            val users = getUsers()
            _uiState.value = UiState.Success(users)
        } catch (e: Exception) {
            _uiState.value = UiState.Error(e.message ?: "Unknown error")
        }
    }
}

---

8. Coroutine Patterns

Structured Concurrency

// ViewModel coroutine scope
class MyViewModel(
    private val repository: UserRepository
) : ViewModel() {
    
    // Best practice: ViewModelScope
    fun loadData() = viewModelScope.launch {
        try {
            val users = repository.getUsers()  // Suspends correctly
            _state.value = users
        } catch (e: Exception) {
            _error.value = e.message
        }
    }
}

// For testing: runBlockingTest
@Test
fun testLoading() = runTest {
    val viewModel = MyViewModel(mockRepo)
    viewModel.loadData()
    
    advanceUntilIdle()  // Wait for coroutines
    verify(mockRepo).getUsers()
}

---

9. Decision Checklist

Before implementing:

• Selected right platform (JVM/Android/KMP)?
• Framework chosen (Ktor/Spring Boot)?
• Coroutines for async, not threads?
• DI framework selected (Koin/Hilt)?
• Database approach chosen?
• Null safety applied?
• Testing strategy defined?

---

❌ Anti-Patterns to Avoid

❌ DON'T:

• Use Java threads with ExecutorService (use coroutines)
• Use lateinit var when you can use nullable/optional
• Use !! operator unless 100% certain
• Write Java-style null checks (if (x != null))
• Use synchronous HTTP in coroutines
• Forget structured concurrency (leaked coroutines)

✅ DO:

• Use data classes for DTOs
• Use sealed classes for Result types
• Use Kotlin flow for streaming
• Use Kotlin 2.0 type inference and prints
• Use ktor-client with suspend functions
• Apply Kotlin idioms (extension functions, infix)
• Learn Kotlin Multiplatform for cross-platform

---

Remember: Kotlin is about null safety and coroutines. Don't write Java in Kotlin. Use idiomatic patterns. Think in Kotlin.