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.
The article explains why recursive enums need the indirect keyword. It covers the problem (value types need a known size at compile time, but recursive cases create infinite size), the solution (indirect stores the case via heap reference), case level versus enum level indirect, practical examples like expression trees and file systems, and trade offs including heap allocation and indirection cost.
The article compares three approaches to thread safety in Swift: actors (language level isolation with compiler enforcement), DispatchQueue (execution level coordination with serial or concurrent queues), and locks (critical section level control). It explains how each works under the hood, including actor reentrancy, queue deadlocks, lock recursion problems, and the new Mutex type from the Synchronization framework. It also covers atomics for simple operations and provides practical guidance on choosing based on safety, performance, API shape, and cognitive load.
The article explains immediate tasks (Task.immediate), a new feature in Swift 6.2 that starts executing synchronously on the caller's executor rather than being scheduled to run later. It covers when to use them (calling async code from synchronous actor code, preserving ordering), the risk of overhang (blocking the caller too long), immediate detached tasks, and immediate child tasks in task groups with addImmediateTask.
This is a transcript of a live Q&A session with Apple engineers answering specific questions about Swift Concurrency. Topics include the difference between Task { @MainActor in } and MainActor.run, the meaning of nonisolated and nonisolated(nonsending), using @concurrent for offloading work, task cancellation best practices, actor limits, the new withDeadline proposal, migration from Swift 5 to Swift 6 concurrency, and testing async code.
The article explains the evolution of onChange() from iOS 14 to iOS 17+. It covers the two new signatures, the initial parameter to trigger the action on first appear, the difference between View and Scene modifiers, and how to avoid blocking the main thread with async code.
