Top 30 Easy Mobile Dev Interview Questions and Answers for Freshers

30 questions. Pick an answer, or open “Show the answer” to read it.

Answers are graded in your browser. Nothing is saved, and no XP or streak is earned here. The app keeps score.

1. Question 1 of 30

   In Kotlin, what does declaring a variable with val guarantee about the referenced object?

   • aAll properties of the object are automatically converted to read-only
   • bThe object becomes deeply immutable and thread-safe by default
   • cThe reference cannot be reassigned, though the object's contents may still mutate
   • dThe compiler prevents any modification to the object's internal state
   Show the answer

   Answer: c · The reference cannot be reassigned, though the object's contents may still mutate

   val only prevents reassigning the reference itself, so a val holding a MutableList can still be modified. The most tempting distractor confuses reference immutability with deep object immutability, which val does not enforce.

   Read the full bite: Explain val vs var in Kotlin and null safety risks

2. Question 2 of 30

   What is the main advantage of Kotlin's approach to null safety with default non-nullable types?

   • aIt allows the !! operator to be used safely in all situations.
   • bIt guarantees that all val variables are compile-time constants.
   • cIt simplifies code by eliminating the need for any null checks.
   • dIt shifts the detection of potential NullPointerExceptions from runtime to compile time.
   Show the answer

   Answer: d · It shifts the detection of potential NullPointerExceptions from runtime to compile time.

   Kotlin's type system is explicitly designed to prevent NullPointerExceptions (NPEs) at compile time, a major benefit over languages that only catch them at runtime. Option B is a common misconception; val declares a read-only reference, not necessarily a compile-time constant.

   Read the full bite: Explain val, var, and null safety in Kotlin

3. Question 3 of 30

   Given the Kotlin declaration `val userNames = mutableListOf("Alice")`, which statement accurately describes the `userNames` variable?

   • aThe code fails to compile because a `val` cannot reference a mutable object.
   • bThe list is completely immutable; no new users can be added or removed.
   • cThe variable `userNames` can be reassigned to a new list, as long as the new list is not null.
   • dThe variable `userNames` cannot be reassigned, but the list it points to can be modified.
   Show the answer

   Answer: d · The variable `userNames` cannot be reassigned, but the list it points to can be modified.

   The `val` keyword creates a read-only reference, meaning the `userNames` variable cannot be reassigned. However, the `mutableListOf` object it points to is still mutable, allowing its contents to be changed. A common misconception is that `val` makes the object itself immutable.

   Read the full bite: Explain val vs. var and null safety in Kotlin

4. Question 4 of 30

   A team needs a niche third-party native SDK that has no Expo support yet wants EAS builds and OTA updates. What is the most accurate take?

   • aThey can use Expo prebuild with a config plugin to integrate the SDK while keeping EAS and OTA
   • bOTA updates are impossible once any custom native code is added
   • cCustom native SDKs only work in Expo Go, not in standalone builds
   • dThey must abandon Expo entirely and use a fully bare setup
   Show the answer

   Answer: a · They can use Expo prebuild with a config plugin to integrate the SDK while keeping EAS and OTA

   Expo prebuild plus a config plugin lets you add arbitrary native code while retaining EAS Build and EAS Update. Abandoning Expo is unnecessary, and Expo Go actually cannot load custom native modules, which is the reverse of the distractor's claim.

   Read the full bite: Expo managed workflow vs bare React Native

5. Question 5 of 30

   Which statement accurately describes a key difference between final and const in Dart?

   • aA final variable can hold a runtime value like DateTime.now(), while const requires a compile-time constant.
   • bfinal variables must be initialized with compile-time constants.
   • cconst variables can be initialized with runtime values like DateTime.now().
   • dfinal prevents all internal mutation of the object it references.
   Show the answer

   Answer: a · A final variable can hold a runtime value like DateTime.now(), while const requires a compile-time constant.

   final allows single assignment at runtime, so DateTime.now() is valid, whereas const requires a compile-time constant and deep immutability. Option D is wrong because final only prevents reassignment of the variable, not mutation of the object's contents.

   Read the full bite: What is the difference between final and const in Dart?

6. Question 6 of 30

   What is the actual effect of declaring a class instance with let in Swift?

   • aThe compiler automatically treats the class as a value type for safety
   • bThe entire instance becomes immutable, preventing any property changes
   • cThe reference cannot be reassigned, but the instance's properties can still be mutated
   • dThe variable can be reassigned, yet the instance's properties become read-only
   Show the answer

   Answer: c · The reference cannot be reassigned, but the instance's properties can still be mutated

   For reference types, let freezes only the pointer, so the variable cannot be reassigned but the object's properties remain mutable. Option B is a common misconception that confuses the reference with the instance itself.

   Read the full bite: What is the difference between let and var in Swift?

7. Question 7 of 30

   If user is null, what happens when evaluating user?.name ?: "Guest"?

   • aIt throws a NullPointerException because safe calls crash on null receivers
   • bIt returns Guest without throwing an exception
   • cIt returns null because the safe call preserves the nullable type
   • dIt requires an explicit null check to compile safely
   Show the answer

   Answer: b · It returns Guest without throwing an exception

   The safe call operator ?. returns null when user is null, and the Elvis operator ?: then substitutes Guest as the fallback. Option C is tempting because ?. does preserve nullability, but it ignores that ?: immediately provides the default value.

   Read the full bite: What do the safe call and Elvis operators do in Kotlin?

8. Question 8 of 30

   Given a nullable `user: User?`, how do you safely get its name's length, returning 0 if either `user` or its `name` property is null?

   • auser?.name?.length
   • buser!!.name!!.length
   • cif (user != null && user.name != null) user.name.length else 0
   • duser?.name?.length ?: 0
   Show the answer

   Answer: d · user?.name?.length ?: 0

   The safe call `?.` accesses properties only if the object is not null, and the Elvis operator `?:` provides the default value `0` if the preceding expression is null. The `if/else` block is verbose and not idiomatic Kotlin.

   Read the full bite: Purpose of Kotlin's safe call (`?.`) and Elvis (`?:`) operators?

9. Question 9 of 30

   Given `data class User(val name: String?)` and a nullable `val activeUser: User?`, which Kotlin expression correctly retrieves the user's name, providing "Guest" if `activeUser` is null or its `name` property is null?

   • aactiveUser!!.name ?: "Guest"
   • bactiveUser.name ?: "Guest"
   • cif (activeUser != null && activeUser.name != null) activeUser.name else "Guest"
   • dactiveUser?.name ?: "Guest"
   Show the answer

   Answer: d · activeUser?.name ?: "Guest"

   Option D correctly uses the safe call operator (?. ) to access 'name' only if 'activeUser' is not null, and then the Elvis operator (?: ) to provide "Guest" if the result is null. Option C, while functionally correct, is considered non-idiomatic Kotlin as it uses a verbose if/else block instead of the more concise and expressive ?. and ?: operators.

   Read the full bite: Purpose of safe call (`?.`) and Elvis (`?:`) operators

10. Question 10 of 30

    Which statement accurately describes Dart's positional and named parameter rules?

    • aPositional parameters are matched by identifier, while named parameters are matched by order.
    • bCurly braces denote optional positional parameters and their defaults use a colon.
    • cOptional positional parameters use square brackets and must appear before named ones.
    • dNamed parameters are always optional and wrapped in square brackets.
    Show the answer

    Answer: c · Optional positional parameters use square brackets and must appear before named ones.

    The card states optional positional parameters use square brackets and must precede named ones, while named parameters use curly braces and can be required. D is the most tempting distractor because it repeats the common red-flag misconception that optional positional parameters use curly braces.

    Read the full bite: Explain Dart positional vs named parameters and write one signature

11. Question 11 of 30

    Which statement accurately describes a Swift Optional's implementation and a safe way to unwrap it?

    • aIt is a compile-time annotation that bypasses type checking, and guard let is only safe inside for loops.
    • bIt is a generic enum with Some and None cases, and it can be safely unwrapped using if let or the nil-coalescing operator.
    • cIt is a reference type that can be nil, and force-unwrapping with ! is the standard way to access its value.
    • dIt is a special pointer similar to null in other languages, and implicitly unwrapped optionals are recommended for daily use.
    Show the answer

    Answer: b · It is a generic enum with Some and None cases, and it can be safely unwrapped using if let or the nil-coalescing operator.

    Swift models Optional as a generic enum with Some and None cases, enforcing nil safety at compile time. The most tempting distractor suggests force-unwrapping is standard, but the card warns that using ! is unsafe and only acceptable when non-nil status is guaranteed.

    Read the full bite: What is an optional in Swift? Demonstrate two safe unwrapping methods.

12. Question 12 of 30

    In Swift, a developer omits the default case in a switch over an Int and covers only a few values. What happens?

    • aIt compiles only if each case ends with an explicit break
    • bIt compiles and silently ignores unhandled values at runtime
    • cIt fails to compile because the switch is not exhaustive
    • dIt compiles but falls through to the next case automatically
    Show the answer

    Answer: c · It fails to compile because the switch is not exhaustive

    Swift requires switches to be exhaustive, so covering only some Int values without a default is a compile error. There is no implicit fallthrough and no break is needed, so the other options describe C behavior, not Swift.

    Read the full bite: How does Swift's switch differ from C's switch?

13. Question 13 of 30

    Why can defining styles with StyleSheet.create be preferable to inline literal objects in a long list?

    • aIt forces all styles to be applied synchronously on the native main thread
    • bIt automatically converts pixel units to platform-independent dp values
    • cIt reuses a stable object reference across renders instead of allocating a new object each time
    • dIt enables CSS cascade and selector matching for nested components
    Show the answer

    Answer: c · It reuses a stable object reference across renders instead of allocating a new object each time

    StyleSheet styles are created once and referenced by key, giving stable references that avoid per-render allocations. React Native has no CSS cascade, and unit handling is not what StyleSheet.create provides.

    Read the full bite: Inline styles vs StyleSheet.create

14. Question 14 of 30

    What is the key behavioral difference between nesting Text inside Text versus nesting components inside a View?

    • aBoth inherit styles identically, so the distinction is purely cosmetic
    • bView children inherit all parent styles automatically, while Text children do not
    • cText inside Text inherits text styles like color and fontSize, while View children do not inherit styles
    • dNeither supports nesting; you must use a single flat component tree
    Show the answer

    Answer: c · Text inside Text inherits text styles like color and fontSize, while View children do not inherit styles

    Nested Text inherits text style properties from its parent Text, which is unique to text rendering. View does not propagate styles to its children, so each child View is styled independently.

    Read the full bite: View vs Text and nesting rules

15. Question 15 of 30

    In Swift, how does declaring an instance with let affect property mutability for a struct compared to a class?

    • aA let struct lives on the stack and cannot be mutated, while a let class on the heap allows property changes.
    • bUsing let makes both structs and classes completely immutable, preventing any property changes after initialization.
    • cWith let, a struct is fully immutable, but a class only fixes the reference so its variable properties can still be mutated.
    • dThe let keyword blocks property changes in classes but not in structs, since structs are copied when modified.
    Show the answer

    Answer: c · With let, a struct is fully immutable, but a class only fixes the reference so its variable properties can still be mutated.

    The card explains that let makes a struct fully immutable, while for a class it only fixes the reference, allowing variable properties to still be mutated. Option B is wrong because it assumes let behaves identically for both, which is a common misconception.

    Read the full bite: Swift struct vs class: differences and when to choose each

16. Question 16 of 30

    In Swift, what is a key advantage of providing default behavior through a protocol extension rather than an abstract base class?

    • aIt allows conforming types to dynamically override defaults at runtime through subclassing.
    • bProtocol extensions can add stored properties to all conforming types.
    • cIt requires conforming classes to use the objc attribute to access the default implementation.
    • dIt enables structs and enums to reuse behavior without being forced into an inheritance hierarchy.
    Show the answer

    Answer: d · It enables structs and enums to reuse behavior without being forced into an inheritance hierarchy.

    Protocol extensions let structs and enums gain shared behavior without being forced into an inheritance hierarchy, unlike abstract base classes. They cannot add stored properties, so any answer suggesting they extend state is incorrect.

    Read the full bite: Explain protocols and how extensions provide default implementations

17. Question 17 of 30

    In Dart, what is the result of building a Map<String, User> with {for (var u in users) u.id: u} when two users share the same id?

    • aThe compiler rejects the code due to duplicate keys
    • bA runtime exception throws because the key already exists
    • cThe last user encountered silently overwrites the previous entry
    • dBoth users are stored under the same key as a List<User>
    Show the answer

    Answer: c · The last user encountered silently overwrites the previous entry

    Dart map literals silently overwrite duplicate keys, so the last user wins without throwing. Many candidates incorrectly assume a runtime exception occurs, but Dart LinkedHashMap simply replaces the previous value.

    Read the full bite: Convert List<User> to Map<String, User> keyed by user id

18. Question 18 of 30

    When running a background task that might fail, how do you defer exception handling until the result is actually needed?

    • aUse `async` and avoid calling `await()` to suppress the exception.
    • bUse `launch` with a `CoroutineExceptionHandler` to catch the error.
    • cUse `launch` and wrap the call to `join()` in a `try-catch` block.
    • dUse `async` and wrap the call to `await()` in a `try-catch` block.
    Show the answer

    Answer: d · Use `async` and wrap the call to `await()` in a `try-catch` block.

    `async` encapsulates any exception, which is re-thrown only when `await()` is called, allowing for deferred handling. In contrast, `launch` propagates exceptions immediately, so a `CoroutineExceptionHandler` would trigger right away.

    Read the full bite: Difference between launch and async in Kotlin Coroutines

19. Question 19 of 30

    For a Kotlin Coroutine task that updates a UI element and does not require a return value, which builder is most appropriate?

    • arunBlocking
    • bwithContext
    • casync
    • dlaunch
    Show the answer

    Answer: d · launch

    The correct choice is launch because it is designed for 'fire-and-forget' operations, such as UI updates, where a direct result is not needed and it returns a Job. Using async for such a task would create a Deferred object whose result is never awaited, potentially leading to silently swallowed exceptions.

    Read the full bite: Explain launch vs. async in Kotlin Coroutines

20. Question 20 of 30

    You need to fetch two pieces of data in parallel inside a ViewModel and return both results to the caller. Which choice best follows structured concurrency?

    • aUse async for both calls and await each Deferred before returning
    • bUse launch for both calls and assign the results to global variables
    • cUse async with a custom Job to prevent cancellation from the ViewModel scope
    • dUse launch because async coroutines are not children of the calling scope
    Show the answer

    Answer: a · Use async for both calls and await each Deferred before returning

    async returns a Deferred that lets you retrieve computed values with await, which is exactly what you need when results must be returned, whereas launch is fire-and-forget. Option C is tempting but wrong because injecting a custom Job breaks the parent-child relationship required by structured concurrency.

    Read the full bite: Explain the difference between launch and async in Kotlin Coroutines

21. Question 21 of 30

    What is the primary effect of a `suspend` function when it needs to wait for a long-running operation like a network request?

    • aIt immediately returns a callback which must be handled to get the result of the operation.
    • bIt can pause the coroutine's execution, freeing the underlying thread to perform other work.
    • cIt automatically moves its execution to a background thread to avoid blocking the caller.
    • dIt blocks the calling thread until the operation completes, guaranteeing sequential execution.
    Show the answer

    Answer: b · It can pause the coroutine's execution, freeing the underlying thread to perform other work.

    A suspend function pauses the coroutine, freeing the thread it was running on for other work. It does not inherently switch threads (that's a dispatcher's job) or block the thread.

    Read the full bite: What is a `suspend` function in Kotlin?

22. Question 22 of 30

    Which statement accurately describes the Kotlin language rule for calling a suspend function?

    • aIt is only permitted from another suspend function or a coroutine builder.
    • bIt can be called from any function as long as kotlinx.coroutines is imported.
    • cIt must always be wrapped in a runBlocking block to compile.
    • dIt can be invoked directly from a regular main function without modification.
    Show the answer

    Answer: a · It is only permitted from another suspend function or a coroutine builder.

    Kotlin enforces that suspend functions run inside a coroutine context, so they can only be called from another suspend function or a builder like launch or async. Option C is tempting because runBlocking is a valid bridge from regular code, but it is not required for every invocation.

    Read the full bite: What is a suspend function in Kotlin and its compiler rules?

23. Question 23 of 30

    What is the fundamental mechanism enabling a Kotlin suspend function to pause execution without blocking its calling thread?

    • aIt uses an internal polling mechanism to check for task completion without yielding the thread.
    • bIt's a special function type that forces the operating system to yield the CPU.
    • cIt automatically delegates the long-running task to a separate background thread.
    • dThe compiler transforms it into a state machine using Continuation-Passing Style.
    Show the answer

    Answer: d · The compiler transforms it into a state machine using Continuation-Passing Style.

    The correct answer is B because the card explicitly states the compiler performs a transformation called Continuation-Passing Style (CPS), which creates a state machine allowing the function to pause and resume. Option C is a common misconception; suspend functions do not inherently move execution to a background thread, as suspension is orthogonal to threading.

    Read the full bite: What is a Kotlin `suspend` function and how does it work?

24. Question 24 of 30

    Which statement accurately describes the difference between final and const fields when declared inside a Dart class?

    • afinal fields must be static, while const fields can be instance fields
    • bconst fields can be initialized with DateTime.now(), while final fields cannot
    • cconst fields must be static, while final fields can be instance fields
    • dfinal values are compile-time constants, while const values are set at runtime
    Show the answer

    Answer: c · const fields must be static, while final fields can be instance fields

    Inside a Dart class, const fields must be static because they are compile-time constants, whereas final fields may be instance-level since they are assigned once at runtime. Distractor A reverses this relationship, a red flag the card specifically identifies.

    Read the full bite: Difference between final and const Dart class properties?

25. Question 25 of 30

    You need to create an object and immediately set several of its properties in a single, concise block. Which scope function is most idiomatic for this configuration task?

    • aalso
    • brun
    • clet
    • dapply
    Show the answer

    Answer: d · apply

    The `apply` function is designed for object configuration. It returns the context object itself, making it perfect for initialization, while `let` and `run` return the lambda result.

    Read the full bite: Explain Kotlin's scope functions: let, run, with, apply, also

26. Question 26 of 30

    You need to configure a new object inside a lambda using receiver syntax, then return the configured object itself for assignment. Which scope function should you use?

    • aapply
    • blet
    • calso
    • drun
    Show the answer

    Answer: a · apply

    apply exposes the object as a receiver (this) and returns the context object itself, making it ideal for builder-style configuration. run is a tempting distractor because it also uses receiver syntax, but it returns the lambda result rather than the configured object.

    Read the full bite: Explain the difference between Kotlin's let, run, with, apply, and also

27. Question 27 of 30

    When configuring an object by setting multiple properties and needing to return the configured object itself, which Kotlin scope function is most appropriate?

    • aapply
    • blet
    • crun
    • dalso
    Show the answer

    Answer: a · apply

    apply is specifically designed for object configuration, allowing direct access to properties via 'this' and returning the configured object itself. run and let return the lambda's result, while also uses 'it' as an argument, making 'apply' the idiomatic choice for this scenario.

    Read the full bite: Explain Kotlin's five scope functions: let, run, with, apply, also

28. Question 28 of 30

    When deduplicating emails in Dart, why is emails.toSet().toList() preferred over manually looping with contains?

    • aIt modifies the original list in place rather than allocating new collections
    • bIt uses the distinct method available on all Dart Iterables to avoid manual loops
    • cIt sorts the emails automatically so duplicates appear next to each other
    • dIt preserves first-occurrence order and runs in average O(n) time instead of O(n^2)
    Show the answer

    Answer: d · It preserves first-occurrence order and runs in average O(n) time instead of O(n^2)

    Converting to a Set uses Dart's LinkedHashSet to drop duplicates in average O(n) time while keeping the first occurrence of each email in its original position. Option B is tempting because distinct sounds like a standard operation, but it is not part of Dart's core Iterable API and comes from external packages like RxDart.

    Read the full bite: Deduplicate a List of emails in Dart

29. Question 29 of 30

    A developer sets the value prop on a TextInput but forgets to handle onChangeText. What happens when the user types?

    • aThe text appears normally because the native input manages its own value
    • bReact throws a runtime error on the first keystroke
    • cThe field appears frozen because state never updates, so value keeps overriding each keystroke
    • dEach keystroke is appended twice due to double rendering
    Show the answer

    Answer: c · The field appears frozen because state never updates, so value keeps overriding each keystroke

    With value bound to unchanging state and no onChangeText to update it, every keystroke is immediately overwritten by the stale state, so the input looks frozen. This is the classic controlled-input mistake, not a thrown error.

    Read the full bite: Controlled TextInput with value and onChangeText

30. Question 30 of 30

    Why is Pressable typically preferred over Button for a custom-styled production button with multiple interaction states?

    • aPressable exposes a pressed state and multiple callbacks, allowing arbitrary custom feedback that Button cannot provide
    • bTouchableOpacity is deprecated and unusable, leaving Pressable as the only option
    • cButton cannot trigger onPress, so it is unsuitable for any real interaction
    • dButton renders faster but blocks long-press events entirely
    Show the answer

    Answer: a · Pressable exposes a pressed state and multiple callbacks, allowing arbitrary custom feedback that Button cannot provide

    Pressable gives a pressed state plus onPressIn, onPressOut, and onLongPress, enabling fully custom feedback, whereas Button is minimally styleable. Button still handles onPress fine, and TouchableOpacity is not deprecated, just less flexible.

    Read the full bite: Button vs TouchableOpacity vs Pressable