Top 30 Intermediate Mobile Dev Concepts Quiz

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

   What is the fundamental mechanism by which Swift Optionals prevent runtime crashes from missing values?

   • aThey automatically substitute a default value for any nil variable at runtime.
   • bThey transform all nil values into safe, empty representations like empty strings or zeros.
   • cThey provide a mechanism to force-unwrap values, guaranteeing their presence at runtime.
   • dThey require explicit checks for nil values at compile time, making absence part of the type.
   Show the answer

   Answer: d · They require explicit checks for nil values at compile time, making absence part of the type.

   The card states Optionals make "the potential absence of a value an explicit part of its type system, forcing developers to handle the 'nil' case at compile time." This explicit handling prevents runtime crashes by ensuring nil is addressed before code execution. Force-unwrapping (option C) is explicitly mentioned as an anti-pattern that causes crashes if the value is nil, not prevents them.

   Read the full bite: Swift Optionals: Handling Nothing Safely

2. Question 2 of 30

   Which statement accurately describes Metro's primary role in a React Native project?

   • aIt handles the compilation of platform-specific native code for iOS and Android.
   • bIt manages the installation and versioning of third-party JavaScript libraries.
   • cIt compiles multiple JavaScript source files into a single, optimized bundle for execution.
   • dIt provides the core framework for building user interfaces with React components.
   Show the answer

   Answer: c · It compiles multiple JavaScript source files into a single, optimized bundle for execution.

   Metro's core function is to act as a "specialized compiler" that takes numerous JavaScript files, resolves dependencies, transforms code, and combines them into a single, optimized bundle for efficient loading on devices. Option B describes a package manager, C describes native build tools, and D describes the React Native framework itself.

   Read the full bite: Metro: The JavaScript Bundler for React Native

3. Question 3 of 30

   When should a developer generally prefer using a Swift struct over a class for a new data type?

   • aWhen the data type needs to be managed by Automatic Reference Counting (ARC).
   • bWhen the data is simple, self-contained, and changes to a copy should not affect the original.
   • cWhen the data represents a unique entity that needs a shared identity across the application.
   • dWhen the data type requires inheritance from another type.
   Show the answer

   Answer: b · When the data is simple, self-contained, and changes to a copy should not affect the original.

   Structs are value types, meaning they are copied on assignment, and changes to the copy do not affect the original. This makes them suitable for simple, self-contained data where independent copies are desired. Classes are used for shared identity and inheritance, and are managed by ARC.

   Read the full bite: Swift Structs vs. Classes: Value vs. Reference Types

4. Question 4 of 30

   You add a new case to a widely-used enum. When does this silently undermine compile-time safety?

   • aWhen the new case carries associated values of different types
   • bWhen switches over the enum include a default clause
   • cWhen the enum is defined with raw String values
   • dWhen switches over the enum omit a default clause
   Show the answer

   Answer: b · When switches over the enum include a default clause

   A default clause catches the new case automatically, so the compiler cannot force you to handle it explicitly. Omitting a default clause produces a build error for unhandled cases, which preserves compile-time safety.

   Read the full bite: Swift Enums: Type-Safe Choice Modeling

5. Question 5 of 30

   What is the primary reason Kotlin classes are final by default?

   • aTo encourage explicit design for inheritance and promote composition over inheritance.
   • bTo optimize runtime performance by allowing the compiler to inline method calls more aggressively.
   • cTo ensure that all class properties are immutable unless explicitly marked as mutable.
   • dTo prevent developers from creating circular dependencies in class hierarchies.
   Show the answer

   Answer: a · To encourage explicit design for inheritance and promote composition over inheritance.

   The card states that Kotlin's design makes inheritance an intentional act to encourage more robust code and promotes composition over inheritance. Option A directly captures these core reasons. Option C is incorrect as 'final by default' relates to inheritance, not the mutability of properties, which is controlled by 'val' and 'var'.

   Read the full bite: Kotlin Inheritance: Open for Extension, Closed by Default

6. Question 6 of 30

   You need to store a collection of unique product SKUs that are currently in stock and frequently check if a particular SKU is available. Which Dart collection is the most efficient choice for this task?

   • aSet, because it guarantees uniqueness and optimizes for fast existence checks.
   • bList, because it allows for easy iteration over all SKUs.
   • cMap, using the SKU as the key and a boolean as the value to indicate availability.
   • dAn ordered List, to quickly find SKUs using binary search if sorted.
   Show the answer

   Answer: a · Set, because it guarantees uniqueness and optimizes for fast existence checks.

   Set is specifically designed for storing unique items and provides highly efficient checks for an item's existence, making it ideal for this scenario. While a Map can also provide fast lookups, a Set is the most direct and efficient choice when only uniqueness and existence checking are required, without needing to associate a value.

   Read the full bite: Dart Collections: Choosing List, Set, or Map

7. Question 7 of 30

   For which scenario is using platform-specific file extensions (e.g., MyComponent.ios.js) the most appropriate solution?

   • aAdjusting a single style property, like background color, for each platform.
   • bApplying a minor API workaround based on the operating system version.
   • cSetting a boolean configuration flag that varies between iOS and Android.
   • dImplementing a component with fundamentally different structure and behavior on iOS and Android.
   Show the answer

   Answer: d · Implementing a component with fundamentally different structure and behavior on iOS and Android.

   Platform-specific file extensions are recommended when a component's structure, behavior, or dependencies are fundamentally different between platforms. Options A, C, and D describe small, inline differences that are best handled with the Platform module's select method or OS checks, as using separate files for these would be overkill.

   Read the full bite: React Native: Platform-Specific Code

8. Question 8 of 30

   Which statement accurately describes the behavior of the copy() method generated for a Kotlin data class?

   • aIt creates a new instance where all properties, including nested mutable objects, are deep copied.
   • bIt is primarily used for destructuring declarations, not for creating new instances.
   • cIt only copies properties that are explicitly marked as val in the primary constructor.
   • dIt performs a shallow copy, meaning references to mutable objects within the data class are shared between the original and the new instance.
   Show the answer

   Answer: d · It performs a shallow copy, meaning references to mutable objects within the data class are shared between the original and the new instance.

   The card explicitly states that the copy() function creates a shallow copy. This means if a data class contains a mutable object, both the original and the copied instance will refer to the same mutable object. Option A is a common misconception, as many expect a copy function to perform a deep copy for safety.

   Read the full bite: Kotlin Data Classes: Automatic Boilerplate for Data Holders

9. Question 9 of 30

   What is the fundamental mechanism by which Hermes improves React Native app startup performance?

   • aIt dynamically optimizes JavaScript code during runtime using a Just-In-Time (JIT) compiler.
   • bIt replaces JavaScript with a more performant native language for critical UI components.
   • cIt significantly reduces the final app's JavaScript bundle size by automatically tree-shaking unused modules.
   • dIt performs Ahead-Of-Time (AOT) compilation of JavaScript into optimized bytecode during the app's build phase.
   Show the answer

   Answer: d · It performs Ahead-Of-Time (AOT) compilation of JavaScript into optimized bytecode during the app's build phase.

   Hermes is an Ahead-Of-Time (AOT) focused engine that pre-compiles JavaScript into optimized bytecode during the build process, reducing the work the device has to do at startup. While it contributes to a smaller app size, its primary mechanism for faster startup is not tree-shaking or JIT compilation.

   Read the full bite: Hermes: The JS Engine for Faster React Native Apps

10. Question 10 of 30

    Which scenario best justifies using Swift's explicit error handling system (with "throws" and "do-catch")?

    • aAs the primary method for all functions that might not successfully complete their task.
    • bTo signal a critical bug that indicates a programming error and should crash the application.
    • cWhen a function might return nil and no specific error message is required.
    • dFor operations that can fail in various ways, requiring the caller to understand the specific type of failure to recover.
    Show the answer

    Answer: d · For operations that can fail in various ways, requiring the caller to understand the specific type of failure to recover.

    The card states Swift's error handling is for "recoverable errors where the caller needs context about what went wrong." Option D directly reflects this, emphasizing the need for specific failure context. Option A is incorrect because the card advises using optionals for simple binary success/failure without extra context.

    Read the full bite: Swift Error Handling: Throwing, Catching, and Propagating

11. Question 11 of 30

    How does Dart's sound null safety fundamentally alter variable nullability?

    • aThe language completely removes the concept of null, replacing it with optional types.
    • bVariables are non-nullable by default, requiring explicit opt-in for nullability.
    • cNull values are automatically converted to default non-null values at runtime.
    • dVariables are nullable by default, requiring explicit non-null declarations.
    Show the answer

    Answer: b · Variables are non-nullable by default, requiring explicit opt-in for nullability.

    Dart's sound null safety makes variables non-nullable by default, meaning they are guaranteed to hold a value. To allow a variable to be null, developers must explicitly opt-in by adding a '?' to its type. Option D describes the opposite behavior, which is common in many other languages but not Dart with null safety.

    Read the full bite: Dart's Sound Null Safety: No More Null Errors

12. Question 12 of 30

    Which fundamental design aspect of the React Native Bridge is primarily responsible for its performance limitations and visible UI jank?

    • aThe necessity of compiling JavaScript code to native machine instructions.
    • bIts asynchronous message passing mechanism between the JavaScript and native threads.
    • cThe overhead introduced by serializing and deserializing all messages into JSON format.
    • dThe requirement for all UI components to be rendered directly by the JavaScript thread.
    Show the answer

    Answer: b · Its asynchronous message passing mechanism between the JavaScript and native threads.

    The card explicitly states that the Bridge's asynchronous nature and the inherent delays it causes are the source of its main limitations, leading to UI jank and preventing synchronous UI layout access. While JSON serialization adds overhead, the core problem causing delays and visual 'jumps' is the asynchronous communication.

    Read the full bite: The React Native Bridge: Why It's Being Replaced

13. Question 13 of 30

    Under which circumstance is it generally recommended to reconsider using a chain of standard Kotlin collection operations (like filter followed by map) and opt for an alternative?

    • aWhen the collection elements need to be processed in a specific, non-sequential order.
    • bWhen the collection is extremely large, and creating intermediate lists would be inefficient.
    • cWhen the desired output is a single aggregated value, not a transformed collection.
    • dWhen the transformation logic requires accessing external mutable state.
    Show the answer

    Answer: b · When the collection is extremely large, and creating intermediate lists would be inefficient.

    Standard chained collection operations create new intermediate lists for each step, which can be very inefficient for large collections. In such cases, using 'asSequence()' or a traditional loop is preferred to avoid this overhead. Option C is incorrect because aggregation can also be achieved using functional operations like 'reduce' or 'fold'.

    Read the full bite: Kotlin Collections: Think Transformations, Not Loops

14. Question 14 of 30

    When is it most appropriate to use Expo Application Services (EAS)?

    • aDuring the initial phase of development to quickly prototype UI components in Expo Go.
    • bFor managing project dependencies and installing native modules directly on your local machine.
    • cTo start a local development server and debug JavaScript code on a simulator or device.
    • dWhen preparing a production-ready build for app store submission or pushing over-the-air updates.
    Show the answer

    Answer: d · When preparing a production-ready build for app store submission or pushing over-the-air updates.

    EAS is designed for production workflows, handling cloud builds, app store submissions, and over-the-air updates for React Native apps. It is explicitly stated as distinct from local development tools like the `expo` CLI, which are used for prototyping and running local development servers.

    Read the full bite: Expo Application Services (EAS): The Cloud Toolchain for React Native

15. Question 15 of 30

    Which statement accurately describes the primary function of Dart's null-aware access operator (?. )?

    • aIt safely attempts to access a member, returning null if the object itself is null.
    • bIt assigns a value to a variable only if that variable is currently null.
    • cIt asserts that a value is non-null, causing a runtime error if it is null.
    • dIt provides a fallback value if the preceding expression evaluates to null.
    Show the answer

    Answer: a · It safely attempts to access a member, returning null if the object itself is null.

    The null-aware access operator (?. ) safely checks if an object is null before attempting to access its members. If the object is null, the expression short-circuits and returns null, preventing a runtime error. Option D describes the if-null operator (??), and Option C describes the unsafe not-null assertion operator (!).

    Read the full bite: Dart's Null-Aware Operators: Safely Handle Nulls

16. Question 16 of 30

    When using Dart's cascade notation (..), what is a crucial difference compared to standard method chaining (.)?

    • aCascade notation is primarily for methods that return void, while method chaining is for methods that return an object.
    • bCascade notation always returns a new object after applying all operations.
    • cThe entire cascade expression evaluates to the original object, not the result of the last operation.
    • dCascade notation allows calling methods on different objects within the same chain.
    Show the answer

    Answer: c · The entire cascade expression evaluates to the original object, not the result of the last operation.

    The card explicitly states that the cascade expression gives back the original object, not the result of the final task, which is the crucial difference from standard method chaining. Option B is incorrect because cascade notation modifies the original object in place and returns it, rather than creating a new one.

    Read the full bite: Dart's Cascade Notation: Chain Calls on One Object

17. Question 17 of 30

    What is the most direct consequence of calling an `async` function in Dart without using the `await` keyword?

    • aThe variable assigned the result will hold a `Future` object instead of the completed value.
    • bThe function's execution will block the main thread, causing the UI to become unresponsive.
    • cA runtime exception will be thrown immediately, indicating an unhandled `Future`.
    • dThe `async` function will not start its execution until explicitly awaited later.
    Show the answer

    Answer: a · The variable assigned the result will hold a `Future` object instead of the completed value.

    The card explicitly states that forgetting `await` results in receiving a `Future` object instead of the actual data, which can lead to downstream type errors. The `async` function itself still executes non-blockingly, and it doesn't immediately throw an exception or prevent execution.

    Read the full bite: Dart's async/await: Non-Blocking Code That Reads Synchronously

18. Question 18 of 30

    In Swift, when is using a capture list with `self` most critical to prevent a retain cycle?

    • aWhen a closure is immediately executed within a function.
    • bWhen a closure is stored as a property of a class instance and references `self`.
    • cWhen a closure is passed as a parameter to a global utility function.
    • dWhen a closure is used to iterate over an array (e.g., map or filter).
    Show the answer

    Answer: b · When a closure is stored as a property of a class instance and references `self`.

    Option B correctly identifies the scenario where a retain cycle is most likely: when a closure is stored as a property of a class instance and captures `self`. This creates a strong reference from the instance to the closure and from the closure back to the instance. Option A describes a closure that is executed immediately, which does not typically lead to a retain cycle because the closure does not outlive the function call.

    Read the full bite: Retain Cycles and Capture Lists in Swift

19. Question 19 of 30

    Which characteristic primarily explains why ScrollView is discouraged for long, dynamic lists?

    • aIts scrolling performance degrades due to complex layout calculations for many off-screen elements.
    • bIt struggles to update individual items efficiently when data changes.
    • cIt renders all its child components into a single view at once, consuming significant resources.
    • dIt does not provide built-in optimizations for displaying large numbers of similar items.
    Show the answer

    Answer: c · It renders all its child components into a single view at once, consuming significant resources.

    The card explicitly states that ScrollView renders every single item, even those off-screen, leading to poor performance and high memory consumption. This simultaneous rendering of all content is the fundamental limitation, while other options describe consequences or secondary issues.

    Read the full bite: ScrollView: For Simple, Bounded Content

20. Question 20 of 30

    Two threads hold references to the same Swift array through two variables, a and b, and both threads call a mutating method on their variable at the same time without any lock. What is the risk?

    • aThe second mutation will simply block until the first one finishes, since Swift arrays use an internal lock
    • bSwift will throw a compile-time error preventing the code from building in the first place
    • cThe isKnownUniquelyReferenced check itself is not thread-safe, so concurrent mutation can race and corrupt the shared buffer
    • dNothing, because copy-on-write automatically makes every mutation thread-safe by design
    Show the answer

    Answer: c · The isKnownUniquelyReferenced check itself is not thread-safe, so concurrent mutation can race and corrupt the shared buffer

    Copy-on-write's uniqueness check and buffer swap are not synchronized, so two threads racing through them concurrently can corrupt shared state or crash. Arrays are not automatically thread-safe, there is no internal lock making one mutation block for the other, and this is a runtime hazard the compiler cannot catch.

    Read the full bite: Copy-on-Write (CoW) in Swift

21. Question 21 of 30

    Which problem does Kotlin's Structured Concurrency primarily aim to solve?

    • aAvoiding UI freezes caused by CPU-bound tasks on the main thread.
    • bSynchronizing shared mutable state in concurrent operations.
    • cManaging thread pools and their associated overhead.
    • dPreventing resource leaks from uncancelled background tasks.
    Show the answer

    Answer: d · Preventing resource leaks from uncancelled background tasks.

    Structured concurrency's main purpose is to enforce lifetime management for concurrent work, preventing resource leaks and unnecessary work by ensuring background tasks are cancelled when no longer needed. While other options are valid concurrency concerns, they are not the primary problem addressed by structured concurrency itself.

    Read the full bite: Structured Concurrency in Kotlin

22. Question 22 of 30

    What is the primary reason to use an associated type within a Swift protocol?

    • aTo ensure that all types conforming to the protocol use the same specific type for a particular element.
    • bTo enable the protocol to refer to a type whose concrete definition is only known by conforming types.
    • cTo permit the protocol itself to be used directly as a concrete type for variables and collections.
    • dTo allow the protocol to inherit generic parameters from a superclass or parent protocol.
    Show the answer

    Answer: b · To enable the protocol to refer to a type whose concrete definition is only known by conforming types.

    Associated types exist to allow a protocol's blueprint to refer to a type that is not known until a concrete type adopts the protocol, making the protocol generic over types it uses. Option C is a tempting distractor because, while desirable, the card explicitly states that protocols with associated types cannot be used directly as concrete types for variables or collections without workarounds.

    Read the full bite: Associated Types: Making Protocols Generic

23. Question 23 of 30

    What is the recommended approach for managing user input in a React Native TextInput?

    • aProvide an initial defaultValue prop and access the current input using a ref's getText() method.
    • bAllow the TextInput to manage its own internal state, retrieving the final value with a ref.
    • cSet the value prop to a state variable and update it via the onChangeText callback.
    • dDirectly modify the TextInput's content from a global store whenever the user types.
    Show the answer

    Answer: c · Set the value prop to a state variable and update it via the onChangeText callback.

    The card emphasizes treating TextInput as a controlled component, where the app's state is the single source of truth, updated by onChangeText and reflected by the value prop. Option B describes an uncontrolled component, which is not the recommended mental model for TextInput.

    Read the full bite: React Native TextInput: Handling User Input

24. Question 24 of 30

    For which scenario is React Native's Pressable component most beneficial compared to a simple Button or View with an onPress handler?

    • aWhen you need to ensure the component is always rendered with native performance optimizations.
    • bWhen you need to prevent accidental presses by requiring a double-tap gesture.
    • cWhen you want to detect specific touch stages like a finger pressing down, holding, or releasing.
    • dWhen you need a standard, platform-styled button with minimal custom logic.
    Show the answer

    Answer: c · When you want to detect specific touch stages like a finger pressing down, holding, or releasing.

    Pressable's core purpose is to provide granular control over touch interactions, allowing detection of events like onPressIn, onLongPress, and onPressOut. The card explicitly states that for standard, platform-styled buttons with minimal logic, the basic Button component is simpler, making option D incorrect.

    Read the full bite: Pressable: A More Powerful Way to Handle Touches

25. Question 25 of 30

    What is the key distinction in how a child coroutine's termination impacts its parent Job?

    • aAn unhandled exception from a child cancels the parent, while a child's normal cancellation does not.
    • bA child's normal cancellation (via cancel()) cancels the parent, but an unhandled exception does not.
    • cNeither a child's normal cancellation nor an unhandled exception will ever cancel the parent.
    • dBoth a child's normal cancellation and an unhandled exception will always cancel the parent.
    Show the answer

    Answer: a · An unhandled exception from a child cancels the parent, while a child's normal cancellation does not.

    The card states that if a child Job fails with an exception (other than CancellationException), it cancels its parent. However, if a child is cancelled normally via cancel() (which uses CancellationException), it does not affect the parent.

    Read the full bite: Kotlin's Job: A Handle to a Background Task

26. Question 26 of 30

    For which scenario is Kotlin's async/await pattern the most appropriate choice?

    • aInitiating a background logging operation that doesn't require its completion to be tracked.
    • bPerforming a sequence of data transformations where each step depends on the previous one's output.
    • cFetching a user's profile and their friends list concurrently from different API endpoints.
    • dExecuting a single, long-running database query without blocking the UI.
    Show the answer

    Answer: c · Fetching a user's profile and their friends list concurrently from different API endpoints.

    The card states that async/await is for running multiple independent, long-running tasks concurrently and combining their results, as exemplified by fetching data from different API endpoints. Option B describes an anti-pattern, as async/await is not for sequential, dependent operations.

    Read the full bite: Kotlin Coroutines: async/await for Parallel Results

27. Question 27 of 30

    What is the primary advantage of using a key path over direct dot notation for property access?

    • aIt stores the current value of a property for immutable access.
    • bIt provides a more performant way to retrieve property values.
    • cIt enables bypassing compile-time type checks for greater flexibility.
    • dIt allows for dynamic, type-safe referencing of properties in generic contexts.
    Show the answer

    Answer: d · It allows for dynamic, type-safe referencing of properties in generic contexts.

    Key paths are designed to pass a type-safe reference to a property itself, enabling generic APIs and dynamic access without losing compile-time safety. Direct dot notation is generally more performant for simple, known property access, making option B incorrect. Key paths enforce type safety, disproving option C, and they refer to the property's location, not its value, making option A incorrect.

    Read the full bite: Key-Path Expressions: Type-Safe Pointers to Properties

28. Question 28 of 30

    What is the primary advantage of using an opaque type (e.g., some Collection) as a function's return type?

    • aIt allows the function to return different concrete types based on runtime conditions.
    • bIt provides flexibility to change the underlying implementation without breaking client code.
    • cIt reduces the need for protocol conformance, simplifying API design.
    • dIt enables the client code to access the specific concrete type's unique methods and properties.
    Show the answer

    Answer: b · It provides flexibility to change the underlying implementation without breaking client code.

    Opaque types hide the concrete return type behind a protocol, allowing the API provider to change the underlying implementation (e.g., from one collection type to another) without affecting client code that only depends on the protocol. Option A is incorrect because a function with an opaque return type must always return the exact same concrete type. Option D is incorrect because the 'opaque' nature means the client only sees the protocol's capabilities, not the concrete type's unique methods.

    Read the full bite: Opaque Types: Hide Implementation, Not Capabilities

29. Question 29 of 30

    What is the primary reason StateFlow is generally not recommended for handling one-time UI events like showing a Snackbar?

    • aIts state-holding nature can cause the event to be re-emitted upon UI re-collection (e.g., config change).
    • bIt's a cold flow and requires an explicit trigger to start emitting.
    • cIt buffers all emitted events, leading to memory issues for frequent one-time actions.
    • dIt only emits values when a collector is active, potentially missing events.
    Show the answer

    Answer: a · Its state-holding nature can cause the event to be re-emitted upon UI re-collection (e.g., config change).

    StateFlow is a state-holder that always provides the current value. If used for one-shot events, its state-holding nature means that a UI re-collection (e.g., after a configuration change) would re-receive the last "event" state, causing the event to trigger again. Options A, B, and D describe incorrect characteristics of StateFlow.

    Read the full bite: StateFlow: A Hot Flow for UI State

30. Question 30 of 30

    What is the primary benefit of Dart's `map()` and `where()` methods being lazy?

    • aThey guarantee that functions with side effects will not be executed.
    • bThey reduce memory consumption by avoiding the creation of temporary intermediate lists.
    • cThey automatically cache computed results for efficient reuse across multiple iterations.
    • dThey ensure that all operations are executed immediately upon declaration.
    Show the answer

    Answer: b · They reduce memory consumption by avoiding the creation of temporary intermediate lists.

    Lazy `map()` and `where()` methods defer computation until elements are actually requested, which prevents the creation of new, temporary lists for each step in a chain of operations. This significantly reduces memory overhead, especially for large datasets. Option C is incorrect because lazy iterables re-evaluate their operations each time they are iterated, unless explicitly materialized with `.toList()`.

    Read the full bite: Dart's Lazy Iterable Methods: map() and where()