Those Who Swift - Issue 279
Weekly note ✏️Swift concurrency stopped being the scary new thing a while ago — it’s just how we write Swift now. But “we adopted it” and “we understand it” are different claims, and this week’s picks live in the gap between them. The theme: concurrency that’s grown past the tutorials and into the parts of real apps where the edges actually are. Wrestling with an isolation error that makes no sense? Reply — those are the best ones to dig into together.
The Delegate Is Dead. Long Live the Actor.with Divya Ravi — Technical Editor, iOS engineer Every Apple framework of a certain age carries the fingerprints of the era it was born in. Open CoreBluetooth, or CoreLocation, or any of the old guard, and you’re not just reading an API — you’re reading 2011. The delegate pattern everywhere. State machines you assemble by hand across six callbacks that fire in an order the compiler knows nothing about. A “did” method for every possible thing that could happen, and a strong-reference dance you have to get exactly right or the whole thing quietly deallocates out from under you. For a decade, that was just the cost of doing business on Apple platforms. We learned it, we internalized it, and we mostly stopped noticing how strange it was. You want to read one value off a Bluetooth sensor? Sixty lines, seven delegate methods, and a comment somewhere that says What’s happening in Swift right now is the slow, deliberate dismantling of that world — and I don’t think we talk about it plainly enough. Structured concurrency didn’t just give us a nicer way to write async code. It changed what the shape of correct code looks like. The delegate era scattered your logic across callbacks because callbacks were the only tool for “tell me when this happens later.” Async/await collapsed that back into something you can read top to bottom: wait for the radio, find the device, connect, stream the readings. The program finally looks like the sentence you’d use to describe it. But here’s the part I actually want to make the case for, because it’s subtler than “async is nicer.” The real shift isn’t syntax. It’s who enforces correctness. In the delegate world, thread-safety was a promise you made to yourself in a comment — “these callbacks arrive on this queue, so be careful.” Nobody checked. You just had to be right, every time, forever, including the time six months from now when a tired version of you touches that file at 4pm on a Friday. Swift 6’s isolation model takes that promise and hands it to the compiler. The actor doesn’t ask you to be careful about which context your state is touched from. It makes touching it from the wrong context not compile. That is a genuinely different relationship with your own code. And it’s why the isolation errors everyone complains about are, I’d argue, mostly a good thing wearing an annoying costume. When the compiler rejects your code with some knotty message about a non-Sendable type crossing an actor boundary, it is usually not being pedantic. It’s telling you about a data race that, in the old world, would have shipped — and surfaced three weeks later as a one-in-ten-thousand crash you could never reproduce. The friction moved earlier. That’s the whole trade. You pay at compile time instead of paying at 2am when the pager goes off. The catch — and there’s always a catch — is that the model is subtle exactly where it matters most. Protocols and global actors interact in ways that surprise even people who’ve been doing this for years. The difference between isolating a protocol, a conformance, and a requirement is real, and getting it wrong produces errors that feel arbitrary until the mental model clicks. That’s the actual work of this era: not memorizing which keyword goes where, but building an intuition for what the compiler is protecting you from, so the errors read as help instead of harassment. So if you’ve been treating Swift concurrency as a box you check — “yes, we migrated, yes, it compiles” — I’d gently push on that. The migration is the easy part. The understanding is the part that pays off, because it’s the difference between fighting the compiler and letting it do the thing it’s uniquely good at: proving, before your code ever runs, that an entire category of bug simply cannot happen. The delegate taught us to be careful. The actor lets us stop having to be. That’s not a small upgrade. That’s the ground moving. What concurrency concept finally clicked for you — and what’s still fighting you? Hit reply. The best answers make next week’s issue. Related reading on this week's theme 📚Concurrency past the tutorials — where the real edges are. Bluetooth Without the Delegate DanceKyle Browning rebuilds CoreBluetooth for the Swift 6.2 era — writing the same heart-rate feature three ways (raw delegates, a 2021 wrapper, and a modern actor-based design) to show exactly how much the language moved. The payoff: tying an actor's isolation directly to CoreBluetooth's delivery queue via custom executors, so events arrive already isolated. A masterclass. 📍Level: Advanced An Even Closer Look at Protocols and Global ActorsMatt Massicotte on the genuinely subtle interaction between protocols and global actors — the difference between isolating a protocol, a conformance, and a requirement, and why getting it wrong produces errors that feel arbitrary until the model clicks. 📍Level: Advanced Swift 6.2 Concurrency in Practice: Default to MainActor, Escape on PurposeBlake Crosley on the mental-model flip in Swift 6.2 — default your module to the main actor, then leave it on purpose in named places. The same data-race guarantee, far fewer false-positive errors, drawn from shipping it across a real app family. 📍Level: Intermediate Building Testable SwiftData AppsMohammad Azam on structuring SwiftData so it's actually testable — keeping persistence at arm's length so your logic runs in tests without a live store fighting you at every step. 📍Level: Intermediate This Week in Those Who Swift 🗞️The latest across Swift, Apple, AI, and the community. Swift Around the Web 🌐What's New in Swift: July 2026 EditionThe official Swift.org digest rounds up the month across the project — releases, evolution proposals, community talks, and the news that Swift now runs in a broader range of IDEs including Cursor, VSCodium, Kiro, and Antigravity via the Open VSX Registry. 📍Level: Beginner Coding 👨💻Managing Focus in SwiftUI with FocusStateNatascha Fadeeva on driving focus properly in SwiftUI — FocusState, programmatic focus changes, and the keyboard-management details that make forms feel right. 📍Level: Intermediate SwiftUI Document APIs in the 2027 Releases: Everything You Need to KnowSagar Unagar on the new Document protocol — snapshot-based updates, efficient disk access, and how it layers on top of the existing FileDocument world without breaking it. 📍Level: Advanced Using SwiftUI's ContentBuilder with Non-View TypesArtem Novichkov digs into ContentBuilder — the unified builder replacing per-container overloads — and how to use it with non-view types, plus what it means for compile times. 📍Level: Advanced iOS 27: Working with the Media Intelligence FrameworkAnton Gubarenko digs into iOS 27’s new Media Intelligence framework — what it exposes, what it’s actually good for, and where it fits alongside the existing media APIs. 📍Level: Intermediate Apple 🍏Hello, Developer: August 2026Apple's monthly developer digest for August — a guided tour of the biggest WWDC26 updates, a walkthrough of building App Store assets for iOS 27, and a profile of the team behind the hit game "Is This Seat Taken?" Design 🎨Concentric Buttons with OS 27's SwiftUI APIsAlexander Weiss on the new concentric-shape APIs in OS 27 — building nested, concentric button shapes that stay aligned the way the new design language expects. 📍Level: Intermediate Adaptive SwiftUI Toolbars in iOS 27Natalia Panferova on the new adaptive toolbar behavior in iOS 27 — how toolbars reflow across size classes and what you get for free versus what you still configure. 📍Level: Intermediate AI & Tooling 🤖Using AI Without Losing Your Critical ThinkingBruno Rocha on staying sharp while leaning on AI tools — a thoughtful, non-hype take on where agents genuinely help and where offloading judgment quietly costs you. 📍Level: Beginner How to Use Git Worktree — and How AI Agents Use ItMohammad Faani on git worktrees — the underused feature that lets you check out multiple branches at once, and why it's suddenly relevant as AI agents work across branches in parallel. 📍Level: Intermediate Video 🎥Previewing SF Symbols with Apple's Own RendererAmy Worrall wires up Apple's own SF Symbols renderer to preview symbols exactly as the system draws them — a neat bit of tooling for anyone who's been squinting at approximations. 📍Level: Advanced Thanks for reading Those Who Swift! Subscribe for free to receive new posts. 👇
|
