More in Android & Kotlin — page 13
What is a CoroutineDispatcher and when to use IO vs Default?
Tests your grasp of thread pool strategy for CPU vs. I/O-bound tasks. A good answer defines Dispatchers, contrasts the fixed-size Default pool (for CPU work) with the larger IO pool (for blocking I/O), and gives clear examples.
Hot vs. Cold Streams: StateFlow vs. Flow in Android
This tests your grasp of stream lifecycles. A great answer defines cold `Flow` (lazy, per-collector) vs. hot `StateFlow` (active, shared state) and uses a ViewModel UI state scenario. A red flag is mischaracterizing a `Flow` as a one-time operation.
Explain Structured Concurrency in Kotlin Coroutines
Tests your grasp of coroutine lifecycle management. A great answer defines the parent-child relationship within a CoroutineScope, explains cancellation propagation, and details how exceptions cancel the entire hierarchy.
Explain Kotlin's five scope functions: let, run, with, apply, also
This tests your grasp of idiomatic Kotlin. A great answer categorizes functions by their context object (`this`/`it`) and return value (object/lambda result). Provide a clear use case for `apply` (object configuration).
What is a Kotlin `suspend` function and how does it work?
Tests your grasp of Kotlin's non-blocking concurrency. A great answer defines a suspend function as pausable, states its two calling rules (from another suspend function or coroutine builder), and mentions the compiler's CPS transformation.
Explain launch vs. async in Kotlin Coroutines
Tests your grasp of structured concurrency, return values, and exceptions. `launch` is for fire-and-forget tasks (returns `Job`), while `async` is for tasks that produce a result (returns `Deferred`).
What problem does `inline` solve, and how does `reified` relate?
This tests your grasp of Kotlin compiler optimizations and JVM type erasure. Explain that `inline` eliminates the runtime overhead of lambda objects. Then, describe how `reified` leverages inlining to make generic types accessible at runtime.
Compare and contrast `apply` and `let` scope functions
Tests Kotlin scope function knowledge: context (`this`/`it`) & return value. `apply` uses `this`, returns the object (for config). `let` uses `it`, returns lambda result (for null-checks/transforms). Red flag: mixing up return values or use cases.
When to use a sealed class instead of an enum?
Tests your grasp of Kotlin's type hierarchies. Use `sealed class` for states with associated data (e.g., `Success(data)`), as subclasses can have unique properties. Use `enum` for simple, constant states. A red flag is treating them as interchangeable.
Explain and implement a Kotlin higher-order function
Tests understanding of first-class functions and lambda usage. First, define a higher-order function (HOF) as one that takes/returns functions. Then, implement the requested function, iterating to apply the predicate and transform.
lateinit var vs. val by lazy in Android
Tests your grasp of Kotlin property initialization and its lifecycle implications. A good answer contrasts mutability (var/val), initialization timing, and thread safety.
What are the advantages of a Kotlin data class and its functions?
Tests knowledge of Kotlin's idiomatic features. A good answer explains the main advantage (boilerplate reduction), lists generated functions like toString() and equals(), and describes copy() for immutable state updates.
What is a Kotlin extension function? Write one for String.
Tests adding functionality to classes without inheritance. Define extension functions as static utilities, explain their use case (e.g., third-party libs), then write `hasWhitespace` using an idiomatic method like `any`. A red flag is manually looping.
Purpose of safe call (`?.`) and Elvis (`?:`) operators
This tests your grasp of Kotlin's idiomatic null safety. Explain the safe call (`?.`) for chaining on nullables and the Elvis operator (`?:`) for providing defaults. Combine them in a one-line example. A multi-line `if/else` is a red flag.
Explain val, var, and null safety in Kotlin
This tests your grasp of immutability and Kotlin's compile-time null safety. Define `val` (immutable reference) vs. `var` (mutable), explain nullable types using `?`, and state the risk is `NullPointerException`. A red flag is confusing `val` with a constant.
Constraints: Building UIs with Relationships, Not Boxes
Constraints define UI by relationships, not nested boxes. Think of it like telling elements 'align with that one' instead of placing them in rigid rows. This is key for complex, responsive layouts, but can lead to unsolvable rules if not defined carefully.
WorkRequest: The Blueprint for Android Background Tasks
A WorkRequest is the blueprint for a background task in Android. It defines *what* work to do and *when*, letting WorkManager handle execution for tasks like syncing data. The footgun is putting logic in the request; it only configures, the Worker acts.
OkHttp Interceptors: Middleware for Your Network Stack
OkHttp Interceptors act as middleware for your network stack, letting you observe, modify, or short-circuit requests and responses. Use them to automatically add auth tokens or log traffic. The main footgun is order: application interceptors run once per call.
Gradle Build Scripts: The Recipe for Your App
Gradle build scripts are your app's recipe, using a declarative DSL to define dependencies and build variants. They manage libraries and create versions like debug vs. release.
Deobfuscating Android Crash Stack Traces
Obfuscated crash reports are useless. Deobfuscation uses a mapping file from your build to translate stack traces back into readable code. This is vital for debugging production apps using R8/ProGuard or native C++.