Intermediate concepts in Mobile Dev
Swift Optionals: Handling Nothing Safely
An Optional is like a box that might contain a value or might be empty (nil). You must safely unwrap it before using the value, preventing crashes. It's used for properties that might not exist yet or for function returns that can fail.
Metro: The JavaScript Bundler for React Native
Metro bundles your React Native app's JavaScript, finding all modules, transpiling them for the device, and merging them into one file. It's what powers npx react-native start.
Swift Structs vs. Classes: Value vs. Reference Types
In Swift, a struct is a copied value (like a new document), while a class is a shared reference (like a link to one document). Use structs for simple data like coordinates; use classes for shared state like a user session.
Swift Enums: Type-Safe Choice Modeling
A Swift enum is a closed menu of possibilities the compiler tracks exhaustively. Use it to replace string constants or model a network result state. Adding a case without updating every switch breaks compile-time safety if you rely on a default clause.
React Native: Platform-Specific Code
React Native lets you write platform-specific logic without ejecting. Use the Platform module for small style tweaks, and file extensions (.ios.js) for swapping entire components. The footgun is overusing Platform.select for complex UI, creating clutter.
Dart Collections: Choosing List, Set, or Map
Dart collections organize data: use a List for ordered items, a Set for unique items, and a Map for key-value pairs. This choice is fundamental for storing UI widgets or parsing JSON. The common footgun is using a List for lookups, which is slow; use.
Kotlin Inheritance: Open for Extension, Closed by Default
In Kotlin, classes are final by default. Think of inheritance as an opt-in feature you enable with the open keyword. Use it to create specialized versions of a base class, like a Student from a Person.
Hermes: The JS Engine for Faster React Native Apps
Hermes is a JavaScript engine optimized for React Native that prioritizes fast startup and low memory use. It's the default for new apps, pre-compiling JS to bytecode at build time. The footgun: don't just check a global variable; benchmark release builds.
Swift Error Handling: Throwing, Catching, and Propagating
Swift error handling uses a dedicated channel for failures. Functions declare they can fail with throws, you handle them with do-catch, or transform them into optionals with try?. The footgun is overusing try!, which crashes your app on failure.
Kotlin Data Classes: Automatic Boilerplate for Data Holders
A Kotlin data class automatically generates boilerplate like equals() and toString() for classes that just hold data. Use it for model objects or DTOs where value equality matters. The footgun: its copy() method is shallow, sharing mutable objects.
Kotlin Collections: Think Transformations, Not Loops
Treat collection operations as a pipeline, not a for loop. Each function (map, filter) transforms data and passes it to the next stage, ideal for turning API data into UI models.
The React Native Bridge: Why It's Being Replaced
Think of the React Native Bridge as an asynchronous JSON message queue between your JavaScript code and the native UI. This design is the source of its core limitation: communication delays that cause visible UI jank and prevent modern React features.
Dart's Sound Null Safety: No More Null Errors
In Dart, variables can't be null unless you explicitly allow it. This flips the usual model, turning potential runtime null pointer crashes into compile-time errors you can fix immediately.
Expo Application Services (EAS): The Cloud Toolchain for React Native
Expo Application Services (EAS) is the cloud toolchain for production React Native apps. It handles complex native builds, app store submissions, and over-the-air updates. The main footgun is confusing it with the local expo CLI for development.
Dart's Null-Aware Operators: Safely Handle Nulls
Null-aware operators let you work with potentially null values without a cascade of if (x != null) checks. Use them to access properties, provide defaults, or assign values only when a variable is null. The footgun is confusing safe ?. with unsafe !.
Dart's Cascade Notation: Chain Calls on One Object
Cascade notation (..) lets you perform a sequence of operations on the same object without repeating its name. It's ideal for configuring new instances in one block.
Dart's async/await: Non-Blocking Code That Reads Synchronously
Dart's async/await makes non-blocking code read like a simple script. Use it for network requests or file I/O to keep your UI from freezing. The biggest footgun is calling an async function but forgetting to await its Future result.
Retain Cycles and Capture Lists in Swift
A retain cycle is a memory leak where two objects hold strong references to each other, preventing deallocation. This often happens in closures that capture self, like network callbacks.
ScrollView: For Simple, Bounded Content
ScrollView is a container for a limited amount of scrollable content, rendering everything inside at once. Use it for short forms or articles where upfront loading is fine. The footgun: it's slow for long lists—use FlatList instead to avoid performance hits.
Copy-on-Write (CoW) in Swift
Copy-on-write lets Swift's Array, Dictionary, Set, and String share one underlying buffer across copies until one is mutated, giving full value-type semantics with the performance of sharing, deferring the actual copy until it is truly needed.
We are hiring for this. Every open role lists the topics its interview covers, so you can prepare for the real thing rather than guessing.
See open roles