Droidcon Berlin: Crafting Idiomatic APIs with Kotlin and Compose

What’s in a language? What does it mean to be idiomatic? Writing clean, intuitive APIs isn’t just about functionality — it’s about designing interfaces that feel natural and intuitive. With Kotlin and Compose, we have a powerful set of tools and syntax that, when used effectively, can reduce cognitive load and make your APIs both elegant and expressive.

In this talk, we’ll dive into the principles of idiomatic Kotlin and explore how they apply to designing Compose APIs. You’ll learn how to leverage Kotlin’s language features, from DSLs and inline functions to advanced type safety and composable conventions, to craft APIs that are a joy to use. By mastering these techniques, you can deliver APIs that not only “work” but truly feel like Kotlin.

Transcript

1. Crafting Idiomatic APIs with Kotlin and Compose Droidcon Berlin - September '25 ashdavies.dev 1
2. What is an API? curl --request GET \ --url "https://api.github.com/octocat" \ --header "Authorization: Bearer YOUR-TOKEN" \ --header "X-GitHub-Api-Version: 2022-11-28" ashdavies.dev 2
3. Protocols SOAP / Rest / GraphQL / gRPC ashdavies.dev 3
4. SDKs ashdavies.dev 4
5. "Ordinary" Code ashdavies.dev 5
6. Everything is an API Droidcon Berlin - Oct '21 ashdavies.dev/talks/everything-is-an-api-berlin-droidcon/ 6
7. Unit Tests ashdavies.dev 7
8. Temporary Code ashdavies.dev 8
9. There is nothing more permanent than a temporary solution ashdavies.dev 9
10. Who is your API for? ashdavies.dev 10
11. Consumers ashdavies.dev 11
12. Colleagues ashdavies.dev 12
13. Future Self ashdavies.dev 13
14. Consequences ashdavies.dev 14
15. Consequences Job security ashdavies.dev 15
16. Consequences Increased learning curve ashdavies.dev 16
17. Consequences Longer peer review ashdavies.dev 17
18. Consequences Slowed feature delivery ashdavies.dev 18
19. Every existing thing is born without reason, prolongs itself out of weakness, and dies by chance — Jean-Paul Sartre ashdavies.dev 19
20. Every line of code is written without reason, maintained out of weakness, and deleted by chance — Jean-Paul Sartre’s Programming in ANSI C. programmingisterrible.com/post/139222674273/write-code-that-is-easy-to-delete-not-easy-to 20
21. Code Maintenance Photo by jessica rigollot 21
22. Idioms kotlinlang.org/docs/idioms.html 22
23. Idioms Default Parameters fun foo(a: Int = 0, b: String = "") { /* ... */ } ashdavies.dev 23
24. Idioms Lazy Properties val property: String by lazy { /* ... */ } ashdavies.dev 24
25. Idioms Null Coalescing val fileSize = files?.size ?: run { val someSize = getSomeSize() someSize * 2 } ashdavies.dev 25
26. Idioms Expression return statements fun getDisplayNameOrDefault(userId: String?): String = getDisplayName(userId ?: return "default") kotlinlang.org/docs/whatsnew2220.html 26
27. Idioms Guard Conditions fun feedAnimal(animal: Animal) { when (animal) { is Animal.Dog -> feedDog() is Animal.Cat if !animal.mouseHunter -> feedCat() else -> println("Unknown animal") } } ashdavies.dev 27
28. Kotlin Coding Conventions kotlinlang.org/docs/coding-conventions.html 28
29. ashdavies.dev 29
30. Feb 2016 Kotlin 1.1 Type Aliases, Bound References, Lambda destructuring Nov 2017 Kotlin 1.2 Array Literals, lateinit properties Oct 2018 Kotlin 1.3 Coroutines, Multiplatform projects, Contracts, when subject Aug 2020 Kotlin 1.4 Sam conversions, explicit API mode, trailing comma May 2021 Kotlin 1.5.0 Sealed interfaces, improved inline classes Nov 2021 Kotlin 1.6.0 Exhaustive when, suspending functions as supertypes Jun 2022 Kotlin 1.7.0 K2 compiler alpha, underscore operator Apr 2023 Kotlin 1.8.20 Wasm target, data objects, secondary constructor bodies May 2024 Kotlin 2.0.0 Compose compiler Gradle plugin Jun 2025 Kotlin 2.2.0 Context parameters, guard conditions, non-local break and continue, multi-dollar interpolation Kotlin ashdavies.dev 30
31. Coroutines ashdavies.dev 31
32. Reactive / Imperative ashdavies.dev 32
33. jakewharton.com/the-state-of-managing-state-with-rxjava/ 33
34. @Suppress("DEPRECATION") class CallbackLoginPresenter(val service: SessionService, val goTo: (Screen) -> Unit) { var onModel: (LoginUiModel) -> Unit = {} var task: AsyncTask<Submit,Void,LoginResult>? = null fun start() = onModel(Content) fun stop() = task?.cancel(true) fun onEvent(event: LoginUiEvent) = when (event) { is Submit -> task = LoginAsyncTask().also { it.execute(event) } } inner class LoginAsyncTask : AsyncTask<Submit, Void, LoginResult>() { private var username: String = "" override fun doInBackground(vararg events: Submit?): LoginResult { val event = events[0]!! username = event.username return runBlocking { service.login(event.username, event.password) } } override fun onPostExecute(result: LoginResult?) = when (result) { is Success -> goTo(LoggedInScreen(username)) is Failure -> goTo(ErrorScreen(result.throwable?.message ?: "")) else -> Unit } } } ashdavies.dev 34
35. Observable.just("Hey") .subscribeOn(Schedulers.io()) .map(String::length) .subscribeOn(Schedulers.computation()) .observeOn(AndroidSchedulers.mainThread()) .doOnSubscribe { doAction() } .flatMap { doAction() Observable.timer(1, TimeUnit.SECONDS) .subscribeOn(Schedulers.single()) .doOnSubscribe { doAction() } } .subscribe { doAction() } proandroiddev.com/how-rxjava-chain-actually-works-2800692f7e13 35
36. Coroutines Structured Concurrency ashdavies.dev 36
37. Declarative Architecture ashdavies.dev 37
38. Declarative Architecture Immutability ashdavies.dev 38
39. Declarative Architecture Idempotency / Determinism ashdavies.dev 39
40. Declarative Architecture Unidirectional Data Flow ashdavies.dev 40
41. Jetpack, Compose, & Multiplatform ashdavies.dev 41
42. ashdavies.dev 42
43. fun Counter($composer: Composer) { $composer.startRestartGroup(-1913267612) /* ... */ $composer.endRestartGroup() } ashdavies.dev 43
44. Compose Higher-Order Functions @Composable fun TopAppBar( navigationIcon: @Composable (() -> Unit)? = null, title: @Composable () -> Unit, actions: @Composable (RowScope.() -> Unit)? = null, // ... ) TopAppBar( navigationIcon = { Image(/* ... */) }, // ... ) chrisbanes.me/posts/slotting-in-with-compose-ui 44
45. Compose Scopes @Stable interface WeightScope { fun Modifier.weight(weight: Float): Modifier } @Composable fun WeightedRow( modifier: Modifier = Modifier, content: @Composable WeightScope.() -> Unit ) { // ... // Usage: WeightedRow { Text("Hello", Modifier.weight(1f)) Text("World", Modifier.weight(2f)) } android.googlesource.com/platform/frameworks/support/+/androidx-main/compose/docs/compose-api-guidelines.md#layout_scoped-modifiers 45
46. Compose Scopes @Composable fun TopAppBar( actions: @Composable (RowScope.() -> Unit)? = null, // ... ) TopAppBar( actions = { ImageButton(onClick = { /* ... */ }) { Image(/* ... */) } ImageButton(onClick = { /* ... */ }) { Image(/* ... */) } }, ) ashdavies.dev 46
47. Compose Property Delegates inline operator fun <T> State<T>.getValue(thisObj: Any?, property: KProperty<*>): T = value val conference by remember { mutableStateOf("Droidcon Berlin") } ashdavies.dev 47
48. Compose Architecture downloadManager .downloadFile("https://.../") .flatMapLatest { state -> when (state) { is State.Loaded -> stateFileManager.saveFile( name = "storage/file", value = state.value, ) else -> state } } .onEach { state -> when (state) { is State.Saved -> println("Downloaded file successfully") is State.Loading -> /* ... */ } } .launchIn(coroutineScope) ashdavies.dev 48
49. RootNode ChildNode ChildNode ChildNode ChildNode ChildNode ChildNode ChildNode ChildNode ChildNode ChildNode ChildNode ashdavies.dev 49
50. val downloadState = downloadManager .downloadFile("https://.../") .collectAsState(State.Downloading) val fileState = when(downloadState) { is State.Loaded -> stateFileManager .saveFile("storage/file", downloadState.value) else -> downloadState } when (fileState) { is State.Loading -> /* ... */ is State.Saved -> LaunchedEffect(fileState) { println("Downloaded file successfully") } } ashdavies.dev 50
51. fun CoroutineScope.launchCounter(): StateFlow<Int> { return launchMolecule(mode = ContextClock) { var count by remember { mutableStateOf(0) } LaunchedEffect(Unit) { while (true) { delay(1_000) count++ } } count } } ashdavies.dev 51
52. Beyond the UI mDevCamp Prague - Jun '25 ashdavies.dev/talks/beyond-the-ui-prague/ 52
53. Language ashdavies.dev 53
54. ! ashdavies.dev 54
55. colour ashdavies.dev 55
56. Luxemburg Netherlands Denmark Belgium Austria Germany Poland UK 0 0.5 1 1.5 2 2.5 3 3.5 4 Average number of languages spoken per person in Europe ashdavies.dev 56
57. fun showCancelBookingAndBackToVerbindungsuebersichtDialog() fun handleLoadBuchungskundenDatenOrOpenRechnungFailure() fun getAngebotsKonditionIconAndContentDescription() ashdavies.dev 57
58. Teuton: Eine Deutsche Programmiersprache # -*- coding: iso-8859-1 -*- schön = Wahr häßlich = Falsch für bäh in [schön, häßlich]: drucke bäh def sovielwiemöglich(): "gib" zurück "was mir gehört" fiber-space.de/EasyExtend/doc/teuton/teuton.htm 58
59. Business Specific Terminology ashdavies.dev 59
60. Stornierung, Ersatzverkehr, Signalstörung... Business Specific Terminology ashdavies.dev 60
61. Business Specific Terminology ashdavies.dev 61
62. What makes a "good" API? ashdavies.dev 62
63. There is no such thing as perfect code ashdavies.dev 63
64. Perfect Solution Fallacy ashdavies.dev 64
65. Documentation /** * A group of *members*. * * This class has no useful logic; it's just a documentation example. * * @param T the type of a member in this group. * @property name the name of this group. * @constructor Creates an empty group. */ class Group<T>(val name: String) { /** * Adds a [member] to this group. * @return the new size of the group. */ fun add(member: T): Int { ... } } ashdavies.dev 65
66. Good code is easy to delete programmingisterrible.com/post/139222674273/write-code-that-is-easy-to-delete-not-easy-to 66
67. High Cohesion - Loose Coupling ashdavies.dev 67
68. Dependency Control ashdavies.dev 68
69. Tooling ashdavies.dev 69
70. Tooling explicitApiMode() kotlinlang.org/docs/whatsnew14.html#explicit-api-mode-for-library-authors 70
71. Tooling com.slack.lint.compose:compose-lint-checks slackhq.github.io/compose-lints/ 71
72. Tooling io.nlopez.compose.rules:ktlint mrmans0n.github.io/compose-rules/ktlint/ 72
73. Tooling @Suppress ashdavies.dev 73
74. Multiline expression wrapping standard:multiline-expression-wrapping val foo = foo( parameterName = "The quick brown fox " .plus("jumps ") .plus("over the lazy dog"), ) ashdavies.dev 74
75. What makes a bad API? ashdavies.dev 75
76. Thank You! ashdavies.dev 76