The article explains how to generate QR codes from text using Core Image's built in qrCodeGenerator filter. It presents QRCodeGenerator as an enum with static functions (acting as a namespace, not an initializable type). The implementation uses CIFilter.qrCodeGenerator(), sets the message as Data from the input string, applies error correction level M, scales the output image (typically by 12x because the raw output is tiny), converts to CGImage then UIImage then SwiftUI Image. The article also covers using .interpolation(.none) to keep edges crisp, separating user input from committed QR code text with two @State properties, and handling failure cases.
The article explains how to use the format parameter in Text and TextField to display and accept formatted values. It covers numbers (notation, grouping, sign, decimal precision), percentages, currencies, dates (date components, intervals, relative dates, ISO 8601), temperatures, distance, file size, concatenating collections with list style, person names using PersonNameComponents, and URLs (hiding scheme, path, or domain). It also shows the difference between interpolated strings and proper formatted numbers (locale awareness), and how TextField with format automatically drops invalid characters.
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.
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.
The article explains what GeometryReader is and how it provides access to a parent container's size and position through GeometryProxy. It covers basic usage (reading width and height), creating responsive grids that adapt column count based on available width, coordinate spaces with global frame conversion, a practical circular progress view example, and caveats about GeometryReader taking all available space by default and potential performance impacts.
The article explains how tasks inherit MainActor isolation from the surrounding context, which creates an unexpected suspension point. A task created on the MainActor must wait for the main thread to become available before it even starts executing, even if its first real operation switches to a different isolation domain. This can cause performance issues, especially when many such tasks are created rapidly. The solution is to start the task on a different isolation domain immediately using Task { @concurrent in } and then jump back to MainActor only when UI updates are needed.
The article explains the motivation and mental model behind Swift Concurrency, starting from the 2017 Concurrency Manifesto. It covers isolation domains (MainActor, custom actors, nonisolated), how isolation propagates through calls and closures, Sendable for safe data crossing, and common problem areas like mixed isolation, detached tasks, MainActor.run, and unstructured concurrency. It also explains actors under the hood (executors, job queues, thread independence), global actors, and the recent shift toward approachable concurrency where async code stays in the caller's isolation domain by default.
