Advanced everything in Mobile Dev, page 13
The Responder Chain: Who Handles That Tap?
The Responder Chain is iOS's chain of command for events. When a user taps the screen, the event travels up a view hierarchy, asking each object, "Can you handle this?" until one accepts. Accidentally breaking this chain can silently kill event handling.
Hunt Retain Cycles with the Memory Graph Debugger
Xcode's Memory Graph Debugger is a visual map of your app's live objects and their relationships. Use it to hunt down memory leaks, especially retain cycles where objects won't deallocate.
Xcode's Time Profiler: Hunting Down Performance Bottlenecks
Time Profiler is a stopwatch for your code, sampling your app's threads to see which functions are running most often. Use it to diagnose slow UI or high battery drain by finding CPU "hot spots."
iOS Provisioning Profiles: Your App's Passport
A provisioning profile is a passport for your iOS app, bundling who can run it (devices), what it can do (entitlements), and who built it (certificate). It's required for running on physical devices and is a common source of build errors.
async/await: Write Concurrent Code That Reads Synchronously
async/await lets you write asynchronous code that reads like a synchronous story, eliminating callback hell. It's ideal for network requests or file I/O. The footgun is thinking await blocks a thread; it only suspends the current task.
Automatic Reference Counting (ARC): Swift's Memory Manager
ARC is Swift's automatic memory manager for classes. It's like a landlord tracking tenants: when the last reference to an object is gone, its memory is freed. It's used everywhere in Swift, but the footgun is creating strong reference cycles.
Protocols: Swift's Blueprint for Behavior
Protocols are Swift's blueprints for behavior, enabling composition over inheritance. They're used to decouple dependencies and define shared functionality like Codable. The footgun is mistaking any Protocol for some Protocol, inviting performance costs.
Impeller: Flutter's Jank-Free Rendering Engine
Impeller is Flutter's new rendering engine that pre-compiles shaders to deliver silky-smooth animations. It replaces the Skia engine to eliminate "jank" from on-the-fly shader compilation. The footgun: it only fixes rendering jank, not slow app logic.
Deferred Components: On-Demand Features in Flutter
Think of deferred components as downloadable content for your app. They reduce initial install size by letting you download features on demand. This is ideal for large, rarely-used functions on Android and web, but requires handling loading states and network…
Flutter Code Obfuscation: Hiding Your Logic
Obfuscation makes your compiled Dart code harder to reverse-engineer by renaming symbols to be unreadable. Use it in production builds to protect sensitive logic, but always save the symbol map file to decipher crash reports later.
Testing Flutter Platform Channel Interactions
Mock platform channels to test your Dart code's interaction with native APIs without a real device. Use this for unit tests of features like camera or GPS access. Footgun: These tests only verify the Dart side, not that your native code is correct.
Background Execution and Services in Flutter
Think of background execution as a helper doing heavy lifting off-screen. It keeps your app's UI smooth by running tasks like data processing on a separate thread (Isolate). The footgun is that isolates don't share memory; you must pass data explicitly.
BasicMessageChannel: A Coded Pipe to Native
A BasicMessageChannel is a raw data pipe between Dart and native code that uses a "codec" to translate objects into binary. Use it for streaming data or custom types not handled by MethodChannel. The footgun is a codec mismatch, which causes runtime crashes.
Flutter Add-to-App: Embedding Flutter in Native Apps
Think of Add-to-App as embedding the Flutter engine inside your existing native app, like a super-powered web view. It's for incrementally migrating a large Android or iOS codebase to Flutter without a full rewrite.
Dart FFI: Calling C Code from Dart
Dart FFI is a bridge to the C world, letting you call native C libraries directly from Dart. Use it to access OS APIs or high-performance C/C++ code. The footgun: you must manually manage native memory, risking crashes or leaks if you forget to free.
Canvas Transformations: Moving the Paper, Not the Pen
Think of Flutter's Canvas transformations not as moving your drawing, but as moving the coordinate system itself. This is key for custom painters, like rotating the canvas to draw tick marks on a dial.
Flutter's Physics Simulations: The Simulation Class
Flutter's Simulation class is the engine for physics-based animations, modeling a 1D object's position and velocity over time. It powers realistic scrolling, springs, and gravity effects.
Flutter's Path Class: Drawing Custom Shapes
Flutter's Path is a digital pen for drawing any custom shape. Use it for complex icons, charts, or clipping widgets into non-rectangular forms. The footgun: forgetting moveTo will connect separate parts of your drawing with an unwanted line.
Staggered Animations: Choreographing UI Changes
A staggered animation is a domino effect for your UI. Instead of animating everything at once, you sequence animations with slight delays for a more fluid, polished feel. Use it for list items appearing one by one. The footgun is timing: too long feels slow.
Isar: A Modern NoSQL Database for Flutter Apps
Isar is a fast, local NoSQL database for Flutter, offering static typing and ACID guarantees. Use it for on-device persistence in iOS, Android, and desktop apps. Don't mistake it for a remote database; Isar is for local storage, not cloud sync.
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