IOS
317 bites tagged IOS — interview questions with model answers, and 60-second explainers.
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…
App Groups: Sharing Data Between Your Apps & Extensions
App Groups create a shared 'lockbox' for your apps and extensions on a user's device, bypassing the default app sandbox. Use it to share UserDefaults or files between your main app and its widget. The footgun: you must use specific APIs and manage data sync.
Realm Database
Realm is an object oriented mobile database that stores your Swift model objects directly, without an ORM layer translating to and from SQL, and gives you live objects that automatically update in your UI whenever the underlying data changes.
SQLite: A Database in a Single File
SQLite is a self-contained SQL database engine that lives in a single file. It's ideal for mobile apps needing fast, reliable local data storage without a server. The footgun is using it for high-concurrency write scenarios, where it becomes a bottleneck.
SwiftData
SwiftData is Apple's Swift native persistence framework, introduced in 2023 as a modern layer over the same storage engine Core Data uses. You declare models with the Model macro instead of a visual schema editor, and SwiftUI views stay in sync automatically.
Core Data: An Object Graph, Not Just a Database
Core Data isn't just a database wrapper; it's an object graph manager that can persist data. Use it for complex model layers in iOS/macOS apps, especially for caching or document-based work. The footgun is treating it like a simple ORM.
Keychain Services: A Secure Vault for Small Secrets
Think of Keychain as a system-managed safe deposit box for small secrets like passwords or tokens. It's the go-to for storing API keys or user credentials securely. The main footgun is its clunky C-style API, leading most developers to use a wrapper.
Swift's Codable: Effortless JSON & Data Parsing
Codable is a compiler magic trick that automatically converts Swift objects to and from formats like JSON. It's used constantly for parsing API responses or saving data to disk. The footgun: decoding fails if JSON keys don't exactly match your property names.
FileManager: Your App's Interface to the File System
FileManager is your app's librarian for the file system. Instead of using raw paths, you ask it to find, create, or delete files and directories. Always handle potential errors, as file operations can easily fail.
App Sandbox: A Digital Playpen for Your App
The App Sandbox is a digital playpen for your app, restricting it to its own files and resources. It's a core security feature on iOS and macOS, preventing apps from accessing user data or system files without explicit permission.
UserDefaults: Your App's Junk Drawer for Settings
UserDefaults is a simple key-value store for persisting small bits of data, like a dictionary that saves itself. Use it to remember user preferences like enabling dark mode or a username. The footgun: don't use it for large files or sensitive data.
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.
NavigationSplitView: Adaptive Layouts for All Screen Sizes
NavigationSplitView is a responsive container for multi-column layouts. It shows a sidebar, content, and detail view on large screens but collapses to a stack on small ones. Use it for master-detail UIs like a mail app.
NavigationLink: Pushing Views in SwiftUI
NavigationLink is SwiftUI's declarative way to push a new view onto a navigation stack. You use it inside a `NavigationStack` to create drill-down UIs, like tapping a list item to see its details. The footgun is forgetting the parent `NavigationStack`.
NavigationStack: Programmatic Navigation in SwiftUI
Think of NavigationStack as a pile of views. You push new views onto the stack programmatically by appending to a path array. This is SwiftUI's modern, data-driven way to handle deep navigation, replacing the older, buggier `NavigationView`.
TabView: SwiftUI's Built-in Tab Bar
TabView lets you show different views in the same space, switched by a tab bar. It's the standard for top-level app navigation, like switching between "Home," "Search," and "Profile." The footgun is nesting them; they are for main sections only.
Storyboard Segues: Visual UI Flow in iOS
A Storyboard Segue is a visual arrow connecting two screens in your iOS app, defining a navigation path without writing code. Use them to transition from a list to a detail view. The biggest mistake is forgetting to use `prepare(for:sender:)` to pass data.
UITabBarController: Your App's Main Switchboard
A UITabBarController manages a row of buttons at the bottom of the screen to switch between an app's main sections. Use it for distinct, non-sequential modes like 'Recents,' 'Contacts,' and 'Voicemail'. The footgun is using it for a step-by-step process.
UINavigationController: Stack-Based Screen Management
UINavigationController manages screens like a deck of cards: you push new ones on top and pop them off to go back. It's standard for hierarchical navigation. The footgun is manually changing the stack; always use the provided push/pop methods.
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.
Get IOS bites daily.
Five a day, five minutes, offline. With quizzes so it sticks.
Open testing — you’ll join as an early tester.