More in Mobile Dev — page 34
Difference between launch and async in Kotlin Coroutines
This tests your grasp of coroutine result handling and exception propagation. Explain that `launch` is fire-and-forget (returns `Job`), while `async` is for results (returns `Deferred`). Mention `async` defers exceptions until `await()`.
Explain `inline` and `reified` in Kotlin
Tests your grasp of JVM performance costs and type erasure. A great answer explains how `inline` avoids object allocation for lambdas, and how this enables `reified` to bypass type erasure for runtime checks. A red flag is just saying 'it's for performance'.
Compare and contrast Kotlin's `apply` and `let` scope functions
This tests your grasp of idiomatic Kotlin scope functions. `apply` uses `this` and returns the object, ideal for configuration. `let` uses `it` and returns the lambda result, useful for null-safe chaining.
When would you use a sealed class instead of an enum?
This tests your understanding of state representation. Explain that sealed classes define a hierarchy of types that can hold different data, while enums are a set of singleton constants.
Explain and implement a higher-order function in Kotlin
Tests your grasp of functions as first-class citizens. Define a higher-order function, explain it takes/returns functions, then implement `filterAndTransform` using the specified lambdas.
lateinit var vs. val by lazy in Android
Tests your grasp of Kotlin's non-nullable property initialization. Define `lateinit` (mutable, framework-init) vs. `lazy` (immutable, deferred-init). Use `lateinit` for Views in `onCreate` and `lazy` for expensive objects. Red flag: confusing their mutability.
What are the advantages of a Kotlin data class?
Tests knowledge of Kotlin's boilerplate reduction for data holders. A good answer defines the advantage (conciseness), names generated functions like `equals`, `hashCode`, and `copy`, and explains `copy` for immutable state updates.
What is a Kotlin extension function? Write one for String.
Tests your grasp of adding functionality to existing classes without inheritance. A great answer defines it as syntactic sugar over static methods, explains its use for third-party code, then implements the requested `String.hasWhitespace` function.
Purpose of Kotlin's safe call (`?.`) and Elvis (`?:`) operators?
This tests your grasp of Kotlin's null safety philosophy. A good answer defines the safe call (`?.`) for conditional access and the Elvis operator (`?:`) for default values, then combines them. A red flag is using verbose `if/else` checks for simple cases.
Explain val vs. var and null safety in Kotlin
Tests your grasp of Kotlin's core principles: immutability and compile-time null safety. Define `val` (read-only) vs. `var` (mutable), declare nullables with `?`, and identify the risk as runtime `NullPointerException`s.
Coroutine Exception Handling: launch vs. async
Coroutine builders handle exceptions differently. `launch` propagates them immediately, crashing if unhandled. `async` silently catches them, waiting for you to call `await`. Use a `CoroutineExceptionHandler` on root scopes for global logging.
Why is `LiveData<Boolean>` bad for one-time ViewModel events?
This tests your grasp of state vs. events. A `LiveData<Boolean>` is state; it re-triggers on rotation. Instead, expose events via a `StateFlow` and have the UI call an `eventConsumed()` function on the ViewModel to maintain unidirectional data flow.
How to pass data between Fragments with Jetpack Navigation?
This tests your knowledge of type-safe argument passing in Jetpack Navigation. A good answer defines the argument in XML, uses the Safe Args plugin to generate code, passes data via the Directions class, and retrieves it with the Args class.
Explain ViewModel, Repository, and Data Source in MVVM
This tests your grasp of separation of concerns in Android. A good answer defines ViewModel, Repository, and Data Source roles, then traces the unidirectional data flow. A red flag is having the ViewModel directly access a data source like Retrofit.
What problem does Jetpack ViewModel solve during configuration changes?
This tests your understanding of state loss during configuration changes. A good answer explains that Activities are destroyed on rotation, and ViewModel survives this event, preserving UI state.
How do you diagnose and fix excessive recomposition in Jetpack Compose?
This tests your understanding of Compose's stability system for performance. Use the Layout Inspector and Compiler Metrics to find unstable composables, then fix them with immutable data types and stable lambdas.
remember vs. rememberSaveable: When and Why to Use Each
Tests understanding of Compose state survival. `remember` is for recomposition scope. `rememberSaveable` survives activity recreation and process death via a `Bundle`, requiring custom `Saver`s for complex types. Red flag: saying `remember` survives rotation.
Implement an efficient list in Jetpack Compose
Tests your grasp of UI virtualization in Compose. Answer: Use `LazyColumn` as it only composes visible items. Contrast this with `Column`, which composes all items at once, causing poor performance. Mention the `items` DSL.
Which side-effect handler for a one-time coroutine action in Compose?
This tests your understanding of Compose lifecycles and side-effect handlers. A good answer names `LaunchedEffect(Unit)`, explaining the constant key ensures the effect runs only once. A red flag is suggesting launching coroutines on every recomposition.
Describe state hoisting in Jetpack Compose.
Tests your grasp of unidirectional data flow. Explain state hoisting is moving state up to make composables stateless. This improves reusability, testability, and creates a single source of truth. A red flag is defining it without explaining the benefits.