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.
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.
Kotlin's Job: A Handle to a Background Task
A Job is a handle to a coroutine, letting you manage its lifecycle. You get one from `launch` to control background tasks like network calls. The key footgun: a child's *failure* (Exception) cancels its parent, but a child's *cancellation* does not.
Kotlin's Control Flow Expressions: `if` and `when`
In Kotlin, `if` and `when` are expressions that return a value. This lets you assign their result directly to a variable, replacing Java's ternary operator. The footgun: when used as an expression, you must have an `else` branch to cover all cases.
Appium: Test Your React Native App Like a Real User
Appium tests your app like a real user, tapping and scrolling on actual devices to catch bugs your unit tests miss. It's for verifying full user flows across iOS and Android. The footgun: relying only on unit tests gives a false sense of security.
useSyncExternalStore: For Synchronous External State
`useSyncExternalStore` lets React safely read from external data sources without UI tearing. It's for integrating non-React state, like from Redux or browser APIs, ensuring consistent reads during concurrent rendering.
Reanimated Worklets: Run JS on the UI Thread
A Reanimated worklet is a JS function that runs directly on the UI thread, bypassing the bridge for 60fps animations. They're used in hooks like `useAnimatedStyle` to compute styles without dropping frames. The footgun: worklets capture their entire closure.
useAnimatedStyle: Link Shared Values to Component Styles
The `useAnimatedStyle` hook connects a shared value to a component's style, running animations on the UI thread. It's a reactive StyleSheet for dynamic properties like opacity or transform. The footgun: never mutate shared values inside the hook.
useSharedValue: State for High-Performance Animations
The `useSharedValue` hook creates state that lives on the UI thread, bypassing React's render cycle for animations. Use it with `useAnimatedStyle` to drive smooth, 60fps animations. The footgun: modifying a shared value won't re-render your component.
Bottom Tab Navigator: Core Mobile Navigation
A Bottom Tab Navigator is the classic mobile UI for switching between top-level app sections. It lazily loads screens, mounting them only when first focused to save memory. Use it for primary navigation.