iOS Resources
Hand-picked Articles and Videos

The article explains the three property wrappers for ObservableObject in SwiftUI. @StateObject creates and owns the instance, keeping it alive across view redraws. @ObservedObject is for passing an already owned instance to child views. @EnvironmentObject injects an object implicitly into a view hierarchy to avoid prop drilling. The article also covers the iOS 17 shift to the @Observable macro, which replaces @StateObject and @ObservedObject with @State, eliminates @Published, and enables granular dependency tracking (only views that read a specific property redraw when it changes).

This newsletter issue covers several iOS interview and coding topics. It explains how to answer an undo/redo system question with Core Data (basic undo manager, grouped operations, child contexts for multi-screen flows). It covers designing an Instagram style feed with clarifying questions (content types, ranking algorithm, interactions, offline support, page size, heterogeneous items). It includes a Swift Bite about task cancellation not stopping automatically (need to check Task.isCancelled or try Task.checkCancellation). It also has a hot take that SwiftUI is ready for production but teams may not be ready because they bring UIKit habits.

Two keywords that turn actor isolation from a wall into a precision tool. nonisolated opts a member out of isolation (useful for computed properties that read only constants, and for fixing delegate crashes from CLLocationManager and similar). isolated on a function parameter makes the function run directly on whatever actor you pass in. transaction closure pattern with isolated parameter lets you group multiple operations without multiple suspension points. #isolation captures caller isolation automatically. nonisolated(unsafe) is a migration escape hatch for legacy globals. isolated deinit in Swift 6.2. And the shift from nonisolated async always hopping away to nonisolated(nonsending) vs @concurrent.

A honest look at building a native macOS app entirely in SwiftUI. The author ported Shopie (an iOS wishlist app) to macOS and ran into real platform specific issues. The term "Mac-assed app" means following Mac conventions: keyboard shortcuts, proper selection states in inactive windows, context menus that highlight the target item without changing selection, and drag and drop that you can track. The article covers specific problems. Selection in inactive windows works fine. Selected but unfocused items require manually passing isEmphasized through the environment. Context menus are impossible to detect, so you cannot highlight the target item unless you use List (which is hard to customize). Drag and drop went through three API versions but still gives no way to know if a drag completed successfully outside the window. Keyboard navigation with arrow keys stops working when a TextField has focus (Spotlight style behavior is not possible). Toolbar placements are semantic and platform dependent, making precise layout difficult.

The article explains how Swift's reference counting has evolved. It starts with the early design where objects stored strong and weak counts inline, creating "zombie objects" that remained allocated until all weak references were accessed. It then covers why this changed (memory overhead, concurrency concerns) and the modern side table design where weak references trigger allocation of an external structure. The article explains inline counts, the transition to side tables, how weak and unowned work today (including why unowned crashes), unowned(unsafe), and performance trade-offs between strong, weak, and unowned.

The article explains three strategies for breaking down monolithic SwiftUI views. First, extracting small reusable components by moving chunks of code into dedicated structs with parameters, which improves readability and enables separate previews. Second, using view modifiers (ViewModifier protocol) to encapsulate styling logic, with extensions for clean dot syntax. Third, creating generic containers with @ViewBuilder that can host any content type without knowing it in advance. The article also warns against using computed properties as a shortcut because they hide complexity without decoupling.

The article explains how to configure background app refresh in a SwiftUI app. It covers enabling background capabilities in Xcode, registering task identifiers in Info.plist, scheduling a background task with BGAppRefreshTaskRequest and setting earliestBeginDate, registering a handler using the backgroundTask(.appRefresh) scene modifier, and testing the background fetch in Xcode using a private debug command to simulate a launch.