Kotlin Concepts Every Jetpack Compose Developer Needs

Compose is Kotlin-first, so the Kotlin concepts that matter most are the ones that make UI state explicit: immutable values, data classes, lambdas, sealed types, delegated state, and coroutines. You do not need every advanced language feature before writing Compose, but these tools make state-driven UI far easier to read and test.

Immutable UI models

Prefer a data class and val properties for screen state. Replace the value when something changes instead of mutating a value that the UI cannot observe.

data class ProfileUiState(
    val name: String = "",
    val isLoading: Boolean = false
)

Lambdas for UI events

Composable functions receive data and callbacks. This keeps the UI focused on rendering and lets a ViewModel own application decisions.

@Composable
fun FollowButton(isFollowing: Boolean, onClick: () -> Unit) {
    Button(onClick = onClick) {
        Text(if (isFollowing) "Following" else "Follow")
    }
}

Sealed UI state

Use a sealed interface when the screen has mutually exclusive states such as loading, error, empty, and content. A when expression then makes missing cases obvious.

sealed interface FeedState {
    data object Loading : FeedState
    data object Empty : FeedState
    data class Content(val posts: List<PostUi>) : FeedState
    data class Error(val message: String) : FeedState
}

Delegated Compose state

The by syntax makes a State<T> read like a normal value. Use it for Compose-owned state; keep screen and business state in the ViewModel.

var expanded by rememberSaveable { mutableStateOf(false) }

Coroutines for UI effects

Suspend APIs such as animateScrollToItem need a coroutine. Launch them from a user event, not during rendering.

val scope = rememberCoroutineScope()
Button(onClick = { scope.launch { listState.animateScrollToItem(0) } }) {
    Text("Top")
}

For the broader UI model, read declarative UI in Compose and state hoisting.