Pertanyaan wawancara Kotlin 2.3 kini menjadi salah satu topik yang paling banyak dicari untuk posisi developer Android di tahun 2026. Dengan hadirnya name-based destructuring declarations, stabilisasi context parameters, dan ekosistem Kotlin Multiplatform yang sudah matang, pewawancara mengharapkan kandidat mampu menunjukkan penguasaan fitur-fitur terbaru ini.

Perubahan di Kotlin 2.3

Kotlin 2.3.20, dirilis Maret 2026, memperkenalkan name-based destructuring declarations, perubahan resolusi overload untuk context parameters, dan peningkatan interop KMP dengan C dan TypeScript. Fitur-fitur ini sering muncul dalam wawancara Android senior.

Name-Based Destructuring: Pertanyaan Wawancara Kotlin 2.3 Paling Umum

Sebelum Kotlin 2.3, destructuring declarations bergantung pada fungsi componentN() berbasis posisi. Hal ini menciptakan jebakan yang terkenal: mengubah urutan properti di data class secara diam-diam merusak destructuring yang sudah ada.

Pertanyaan wawancara klasik menyajikan skenario berikut:

User.ktkotlin

data class User(val username: String, val email: String)

fun main() {
    val user = User("alice", "alice@example.com")
    // Position-based: urutan yang penting, bukan nama
    val (email, username) = user
    println(email)    // Mencetak "alice" -- salah!
    println(username) // Mencetak "alice@example.com" -- salah!
}

Kotlin 2.3.20 menyelesaikan masalah ini dengan name-based destructuring. Tiga mode compiler mengontrol perilakunya:

build.gradle.ktskotlin

kotlin {
    compilerOptions {
        // Mode 1: Hanya sintaks eksplisit
        freeCompilerArgs.add("-Xname-based-destructuring=only-syntax")
        // Mode 2: Peringatan saat nama tidak cocok
        // freeCompilerArgs.add("-Xname-based-destructuring=name-mismatch")
        // Mode 3: Name-based penuh sebagai default
        // freeCompilerArgs.add("-Xname-based-destructuring=complete")
    }
}

Dengan mode complete, tanda kurung biasa menggunakan pencocokan berbasis nama, dan tanda kurung siku mempertahankan perilaku berbasis posisi:

NameBasedDestructuring.ktkotlin

data class User(val username: String, val email: String)

fun main() {
    val user = User("alice", "alice@example.com")

    // Name-based: mencocokkan berdasarkan nama properti
    val (email, username) = user
    println(email)    // "alice@example.com" -- benar
    println(username) // "alice" -- benar

    // Position-based: tanda kurung siku mempertahankan perilaku lama
    val [first, second] = user
    println(first)  // "alice" (component1)
    println(second) // "alice@example.com" (component2)
}

Jawaban yang kuat dalam wawancara menjelaskan ketiga mode dan mengidentifikasi kapan masing-masing berlaku: only-syntax untuk migrasi bertahap, name-mismatch untuk menangkap bug di kode yang sudah ada, dan complete untuk proyek baru.

Pertanyaan Wawancara Kotlin Multiplatform untuk Developer Android

KMP telah melewati fase eksperimental. Google secara resmi mendukungnya untuk berbagi logika bisnis antara Android dan iOS, dan sebagian besar proyek multi-platform baru mengadopsi arsitektur shared-core secara default.

Pertanyaan wawancara tipikal bertanya: "Bagaimana Anda menyusun modul KMP untuk shared networking?"

shared/src/commonMain/kotlin/com/app/network/ApiClient.ktkotlin

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json

@Serializable
data class UserProfile(
    val id: String,
    val displayName: String,
    val avatarUrl: String?
)

// Pola expect/actual untuk HTTP engine spesifik platform
expect fun createHttpClient(): HttpClient

class ApiClient {
    private val client = createHttpClient()
    private val json = Json { ignoreUnknownKeys = true }

    // Fungsi suspend yang dibagikan antara Android dan iOS
    suspend fun fetchProfile(userId: String): UserProfile {
        val response = client.get("https://api.example.com/users/$userId")
        return json.decodeFromString(response.bodyAsText())
    }
}

shared/src/androidMain/kotlin/com/app/network/HttpClient.android.ktkotlin

import io.ktor.client.*
import io.ktor.client.engine.okhttp.*

// Android menggunakan engine OkHttp
actual fun createHttpClient(): HttpClient = HttpClient(OkHttp) {
    engine {
        config {
            retryOnConnectionFailure(true)
        }
    }
}

Pewawancara mengevaluasi apakah kandidat memahami mekanisme expect/actual, dependensi spesifik platform, dan batas antara kode yang dibagikan dan kode platform.

Pertanyaan umum lainnya mencakup Swift Export, yang telah berkembang signifikan di tahun 2026. Fungsi suspend Kotlin kini dipetakan langsung ke async/await Swift, menghilangkan kebutuhan akan wrapper completion handler.

Context Parameters: Pengganti Context Receivers

Context parameters menggantikan fitur context receivers yang sudah usang. Perubahan ini sering muncul sebagai pertanyaan jebakan dalam wawancara karena banyak developer masih menggunakan sintaks lama.

ContextParameters.ktkotlin

class Logger {
    fun log(message: String) = println("[LOG] $message")
}

class Transaction {
    fun execute(query: String) = println("Executing: $query")
}

// Kotlin 2.3: context parameters (stabil)
context(logger: Logger, tx: Transaction)
fun saveUser(id: Int) {
    logger.log("Saving user $id")
    tx.execute("INSERT INTO users (id) VALUES ($id)")
}

fun main() {
    val logger = Logger()
    val tx = Transaction()
    context(logger, tx) {
        saveUser(42)
    }
}

Perubahan penting di Kotlin 2.3.20: resolusi overload untuk context parameters kini mengikuti aturan yang berbeda. Fungsi dengan context parameters tidak lagi secara otomatis diutamakan dari yang tanpa context:

OverloadResolution.ktkotlin

class Logger {
    fun log(message: String) = println("[LOG] $message")
}

// Tanpa context parameter
fun saveUser(id: Int) {
    println("Saving user $id (no logger)")
}

// Dengan context parameter
context(logger: Logger)
fun saveUser(id: Int) {
    logger.log("Saving user $id")
    println("Saving user $id (no logger)")
}

fun main() {
    val logger = Logger()
    // Ini sekarang menghasilkan error ambiguitas di Kotlin 2.3.20
    // context(logger) { saveUser(1) }

    // Perbaikan: ubah nama atau kualifikasi varian context-aware
}

Pewawancara menggunakan topik ini untuk menilai kesadaran akan breaking changes dan strategi migrasi. Poin penting: mengandalkan resolusi implicit context parameter untuk meng-shadow overload non-kontekstual tidak lagi berfungsi.

Coroutines dan Flow: Tetap Menjadi Topik Wawancara Android Teratas

Meskipun Kotlin 2.3 memperkenalkan fitur-fitur baru, coroutines dan Flow tetap menjadi area yang paling banyak diuji. Pertanyaan wawancara biasanya menguji perbedaan antara cold dan hot flow, structured concurrency, dan cancellation.

FlowComparison.ktkotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

// Cold Flow: emit hanya saat di-collect
fun userUpdates(): Flow<String> = flow {
    println("Flow started") // Berjalan per collector
    emit("User logged in")
    delay(1000)
    emit("User updated profile")
}

// Hot Flow: emit secara independen dari collector
class UserRepository {
    // StateFlow menyimpan nilai terbaru
    private val _state = MutableStateFlow("idle")
    val state: StateFlow<String> = _state.asStateFlow()

    // SharedFlow menyiarkan ke beberapa collector
    private val _events = MutableSharedFlow<String>()
    val events: SharedFlow<String> = _events.asSharedFlow()

    suspend fun login() {
        _state.value = "loading"
        delay(500)
        _state.value = "authenticated"
        _events.emit("login_success")
    }
}

Pertanyaan lanjutan sering bertanya tentang mengumpulkan flow dengan aman di Android:

UserViewModel.ktkotlin

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch

class UserViewModel(private val repo: UserRepository) : ViewModel() {

    // Expose state ke Compose UI
    val uiState: StateFlow<String> = repo.state
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = "idle"
        )

    init {
        // Collect events secara aman dalam scope ViewModel
        viewModelScope.launch {
            repo.events.collect { event ->
                // Tangani event satu kali
                println("Event received: $event")
            }
        }
    }
}

Strategi WhileSubscribed(5000) menjaga upstream tetap aktif selama 5 detik setelah subscriber terakhir menghilang, mencegah restart yang tidak perlu selama perubahan konfigurasi seperti rotasi layar.

Siap menguasai wawancara Android Anda?

Berlatih dengan simulator interaktif, flashcards, dan tes teknis kami.

Jelajahi Android

Sealed Classes dan Exhaustive When: Pattern Matching dalam Wawancara

Sealed classes muncul di hampir setiap wawancara Android. Pertanyaannya biasanya meminta kandidat memodelkan UI state:

UiState.ktkotlin

sealed interface UiState<out T> {
    data object Loading : UiState<Nothing>
    data class Success<T>(val data: T) : UiState<T>
    data class Error(val message: String, val retry: (() -> Unit)? = null) : UiState<Nothing>
}

// Penggunaan di ViewModel
fun loadUsers(): Flow<UiState<List<UserProfile>>> = flow {
    emit(UiState.Loading)
    try {
        val users = apiClient.fetchUsers()
        emit(UiState.Success(users))
    } catch (e: Exception) {
        emit(UiState.Error(
            message = e.localizedMessage ?: "Unknown error",
            retry = { /* trigger reload */ }
        ))
    }
}

Di Kotlin, ekspresi when pada sealed types bersifat exhaustive saat compile time. Menambahkan subtype baru memaksa penanganannya di mana pun, yang menghilangkan seluruh kategori bug runtime. Pewawancara secara khusus memeriksa apakah kandidat menggunakan sealed interface (bukan sealed class) untuk pola ini, karena interface memungkinkan hierarki yang lebih fleksibel.

Kotlin/Wasm dan Target Kompilasi Cross-Platform

Kotlin/Wasm telah mencapai status Beta dan menghadirkan performa mendekati native di browser. Meskipun belum menjadi perhatian harian bagi developer Android, pewawancara di perusahaan dengan produk web+mobile menanyakan tentang ini.

Fakta penting untuk wawancara:

Kotlin 2.3.20 menghadirkan interpolasi string 4,6x lebih cepat di Wasm melalui JS String builtins
Ukuran binary berkurang sekitar 5%
Clean build berjalan 65% lebih cepat, incremental build 21% lebih cepat
Anotasi @nativeInvoke memungkinkan objek Kotlin bertindak sebagai fungsi JavaScript

Kotlin/JS juga mendapatkan kemampuan untuk mengimplementasikan interface Kotlin dari TypeScript, menghilangkan batasan sebelumnya. Dikombinasikan dengan dukungan SWC untuk transpilasi, Kotlin kini mencakup Android, iOS (via KMP), Web (via Wasm/JS), dan target server-side dari satu codebase.

Scope Functions: Filter Wawancara yang Menipu dengan Kesederhanaannya

Scope functions (let, run, with, apply, also) tampak sederhana tetapi membedakan developer Kotlin yang berpengalaman. Pertanyaan wawancara biasanya bertanya: "Kapan Anda menggunakan let versus apply?"

ScopeFunctions.ktkotlin

data class Request(
    var url: String = "",
    var method: String = "GET",
    var headers: MutableMap<String, String> = mutableMapOf(),
    var body: String? = null
)

fun buildRequest(): Request {
    // apply: konfigurasi objek, mengembalikan objek
    return Request().apply {
        url = "https://api.example.com/users"
        method = "POST"
        headers["Content-Type"] = "application/json"
        body = "{\"name\": \"Alice\"}"
    }
}

fun processNullable(input: String?) {
    // let: transformasi nullable, mengembalikan hasil lambda
    val length = input?.let { value ->
        println("Processing: $value")
        value.trim().length
    } ?: 0

    // also: efek samping, mengembalikan objek asli
    input?.also { println("Logging input: $it") }

    // run: eksekusi blok dengan receiver, mengembalikan hasil lambda
    val result = input?.run {
        // 'this' adalah string
        uppercase().take(10)
    }
}

Kerangka keputusan: apply untuk konfigurasi objek (mengembalikan receiver), let untuk transformasi null-safe (mengembalikan hasil lambda), also untuk efek samping (mengembalikan receiver), run untuk menghitung hasil dengan konteks receiver.

Null Safety dan Bahaya Double-Bang

Null safety tetap menjadi topik wawancara fundamental. Pertanyaan "Mengapa !! berbahaya?" menguji apakah kandidat benar-benar memahami sistem tipe Kotlin.

NullSafety.ktkotlin

fun findUser(id: String): User? {
    // Mengembalikan null jika user tidak ditemukan
    return database.queryUser(id)
}

// Buruk: !! mengalahkan tujuan null safety
fun riskyApproach(id: String) {
    val user = findUser(id)!! // NullPointerException jika null
    println(user.username)
}

// Baik: tangani null secara eksplisit
fun safeApproach(id: String) {
    val user = findUser(id) ?: run {
        println("User not found")
        return
    }
    println(user.username)
}

// Baik: berikan default dengan Elvis operator
fun displayName(id: String): String {
    return findUser(id)?.username ?: "Anonymous"
}

Jawaban lengkap menyebutkan bahwa !! hanya boleh muncul di kode tes atau batas interop platform di mana null benar-benar tidak mungkin terjadi.

Mulai berlatih!

Uji pengetahuan Anda dengan simulator wawancara dan tes teknis kami.

Buat akun gratis saya

Kesimpulan

Name-based destructuring di Kotlin 2.3.20 menghilangkan bug bergantung posisi. Ketahui ketiga mode compiler: only-syntax, name-mismatch, complete
KMP sudah stabil di produksi pada tahun 2026. Persiapkan pertanyaan tentang expect/actual, arsitektur shared module, dan interop Swift Export
Context parameters menggantikan context receivers. Perubahan resolusi overload di 2.3.20 adalah pertanyaan jebakan umum
Coroutines dan Flow mendominasi wawancara Android. Kuasai StateFlow vs SharedFlow, WhileSubscribed, dan structured concurrency
Sealed interfaces memodelkan UI state dengan exhaustiveness saat compile-time. Utamakan sealed interface daripada sealed class
Scope functions membutuhkan kerangka keputusan yang jelas: receiver vs argument, return value vs receiver
Null safety tidak bisa ditawar. Artikulasikan mengapa !! merusak sistem tipe dan tunjukkan alternatifnya

Mulai berlatih!

Uji pengetahuan Anda dengan simulator wawancara dan tes teknis kami.

Buat akun gratis saya

Kotlin 2.3 untuk Android: Name-Based Destructuring, KMP dan Pertanyaan Wawancara 2026

Name-Based Destructuring: Pertanyaan Wawancara Kotlin 2.3 Paling Umum

Pertanyaan Wawancara Kotlin Multiplatform untuk Developer Android

Context Parameters: Pengganti Context Receivers

Coroutines dan Flow: Tetap Menjadi Topik Wawancara Android Teratas

Siap menguasai wawancara Android Anda?

Sealed Classes dan Exhaustive When: Pattern Matching dalam Wawancara

Kotlin/Wasm dan Target Kompilasi Cross-Platform

Scope Functions: Filter Wawancara yang Menipu dengan Kesederhanaannya

Null Safety dan Bahaya Double-Bang

Mulai berlatih!

Kesimpulan

Mulai berlatih!

Artikel terkait

20 Pertanyaan Wawancara Jetpack Compose Teratas di Tahun 2026

Menguasai Kotlin Coroutines: Panduan Lengkap 2026

Jetpack Compose: Animasi Lanjutan Langkah demi Langkah