Advanced everything in Mobile Dev, page 12
AVCaptureSession
AVCaptureSession is the central coordinator in AVFoundation that connects camera and microphone inputs to outputs like a preview layer, photo capture, movie recording, or real time frame processing.
Core Bluetooth: The Central vs. Peripheral Model
Core Bluetooth lets your app talk to BLE devices by acting as a "Central" (scanner) or "Peripheral" (advertiser). Use it to read from sensors or make your app discoverable.
ARKit: Building Augmented Reality on Apple Devices
ARKit is Apple's framework for blending digital objects with the real world using a device's camera. Use it for games, virtual furniture previews, or measurement tools.
CAReplicatorLayer: A 'For Loop' for Layers
CAReplicatorLayer is a 'for loop' for layers, creating complex patterns from a single source layer. Use it for loading spinners or radial bursts. The footgun: transformations are cumulative, so each copy is transformed relative to the previous one, not the…
GeometryEffect
GeometryEffect is a SwiftUI protocol for building custom animatable 2D transforms beyond the built-in offset, scaleEffect, and rotationEffect modifiers, by returning a ProjectionTransform that SwiftUI recomputes and animates on every frame.
The Animatable Protocol
The Animatable protocol lets a custom SwiftUI view or Shape expose its state as interpolatable data, so SwiftUI can smoothly tween between values across frames instead of snapping, which is how custom shapes and progress indicators get real animation.
CATransaction: Grouping Core Animation Changes
Think of CATransaction as an atomic 'commit' for UI animations, grouping layer property changes to appear at once. Use it to synchronize animations or set a custom duration for a batch of changes.
CAKeyframeAnimation: Animating Through Key States
CAKeyframeAnimation defines animations with waypoints, not just a start and end. Think of it as a flipbook where you set key frames and the system interpolates. Use it for complex paths, like shaking an icon. Footgun: setting both path and values.
TaskGroup: Dynamic, Structured Concurrency in Swift
A TaskGroup is like a manager for parallel jobs. You add a dynamic number of tasks, and it runs them concurrently, ensuring the parent task waits for them all. Use it to fetch multiple images or API data.
NSFetchedResultsController: The Bridge for Core Data & UI
NSFetchedResultsController is a bridge that automatically syncs a Core Data database with a UITableView. It efficiently manages data fetching, memory, and UI updates for dynamic lists, like a social feed.
Core Data Migrations: Evolving Your App's Schema Safely
Core Data migrations are your app's plan for evolving its local data model without losing user data. Use them when shipping a new version that adds or renames attributes. The footgun is assuming 'lightweight' migration works for everything; it doesn't.
NSPersistentContainer: Your Core Data Stack in One Object
NSPersistentContainer is a pre-built engine for Core Data, managing the model, coordinator, and context. It's the standard for iOS 10+ apps. The footgun is forgetting you can customize it or using its main viewContext for heavy background work, which blocks…
Custom UIViewController Transitions: Beyond the Defaults
A custom transition lets you choreograph the handoff between two screens, defining the exact animation. Use it for unique experiences like a card expanding to fill the screen.
NavigationPath (SwiftUI)
NavigationPath is a type erased stack of navigation destinations that backs a SwiftUI NavigationStack, letting one path hold a mix of different hashable data types so you can push, pop and control deep, heterogeneous navigation flows programmatically.
Deep Linking: Go Beyond the App's Home Screen
A deep link is a URL for a specific screen inside your app, not just its front door. Use it to let users jump directly to content from emails, websites, or other apps, but be sure to handle state changes like login before redirecting.
iOS State Preservation: Resume Where You Left Off
Think of it as an automatic bookmark for your app's UI. When iOS terminates your app, state preservation can save the user's place, restoring the view hierarchy on next launch.
VIPER: Taming Massive iOS View Controllers
VIPER is a strict architectural pattern that tames "Massive View Controllers" by splitting features into five layers: View, Interactor, Presenter, Entity, and Router. It's used in large iOS apps to make business logic and navigation explicitly testable.
The Coordinator Pattern: Untangling iOS Navigation
The Coordinator pattern makes a separate object the 'boss' of app navigation, leaving view controllers to just manage their view. This lets you reuse views in different flows without them knowing what comes next.
UIViewRepresentable: Bridging UIKit and SwiftUI
UIViewRepresentable is an adapter that lets you use battle-tested UIKit views inside your modern SwiftUI code. Use it for components like WKWebView that lack a native SwiftUI equivalent.
ObservableObject: Making Data Drive SwiftUI Views
ObservableObject lets your custom data classes signal SwiftUI views to refresh when data changes. Use it for reference types like a user profile or settings manager. Changes are ignored unless you mark properties with @Published, leaving your UI stale.
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