Those Who Swift - Issue 282
Weekly note ✏️“It just works” is doing a lot of quiet work in that sentence. This week’s reads are about the rules hiding underneath four things that feel automatic: how SwiftUI decides a view needs to redraw, which property wrapper actually owns your object, what git really deletes when you force-push over two weeks of work, and what happens when you stop clicking through Xcode and start scripting it directly. Hit reply and tell us: what’s the last “it just works” feature that turned out to have rules you had to learn the hard way?
Every “It Just Works” Has Rules You Haven’t Learned Yet.with Divya Ravi — Technical Editor, iOS engineer Every framework sells you a story. SwiftUI redraws the right views. Git deletes what you tell it to delete. Xcode is where you click things until the app runs. The story is convenient right up until the moment it’s wrong, and then you find out the story was never the whole mechanism — just the part someone decided you didn’t need to see. Natalia Panferova’s piece on SwiftUI data dependencies is a good place to start, because “SwiftUI re-renders when state changes” is the kind of sentence that’s true enough to stop you from asking a better question. Which state? Tracked how? Through what boundary? Panferova walks through the actual dependency graph SwiftUI builds, and once you’ve seen it, the mysterious extra redraw — or worse, the redraw that never happens — stops being mysterious. It was never magic. It was a rule you hadn’t read yet. Antoine van der Lee’s @StateObject-versus-@ObservedObject piece sits right next to that one, because ownership is exactly the kind of thing SwiftUI lets you get away with ignoring until you can’t. Both wrappers will compile. Both will often behave identically in a demo. The difference only shows up when the view holding an @ObservedObject gets recreated and your “persistent” state quietly resets — at which point you learn, expensively, that one of these wrappers was never supposed to be the source of truth. Then there’s Daniel Saidi’s story, which is the most viscerally relatable thing I’ve read this month: an errant [MY STORY GOES HERE — a real first-hand moment where I learned a tool’s actual rules the hard way, ideally something from SDK work where the “convenient model” broke and I had to go find the real one] Artem Novichkov’s MCP-driven Xcode piece rounds this out from a different angle. Instead of learning a hidden rule the hard way, he’s exploiting one on purpose: Xcode and the simulator were never really “a GUI,” they’re a set of programmable interfaces that a GUI happens to sit in front of. Once you talk to that layer directly — prompt to build to simulator, no clicking — a lot of what felt like “the way Xcode works” turns out to have been “the way the GUI chose to expose Xcode.” Different thing entirely. None of these are really stories about bugs. They’re stories about the gap between the interface you were handed and the system actually running underneath it — and about what happens once someone bothers to close that gap for you. The dependency graph, the ownership model, the ref/object split, the automatable toolchain: all of it was always there, documented or discoverable, just not part of the story anyone tells you on day one. I don’t think the answer is to distrust every abstraction you use. Most of them earn the trust, most of the time. But it’s worth noticing which ones you’ve never actually verified — which “it just works” you’ve been repeating because it’s convenient, not because you checked. The rules are usually learnable in an afternoon. The bill for not knowing them tends to come due at a much worse time. Hit reply and tell me: what’s an “it just works” in your stack that you’ve never actually gone and verified? Related reading on this week's theme 📚@StateObject Vs. @ObservedObject: The Differences ExplainedAntoine van der Lee breaks down the ownership rules behind SwiftUI's two reference-type property wrappers — which one actually creates the object, which one just observes it, and why picking the wrong one causes state to quietly reset when a view gets recreated. 📍Level: Intermediate SwiftUI Data Dependencies And Their Effect On View UpdatesNatalia Panferova goes past "SwiftUI re-renders when state changes" to the actual dependency graph that decides whether a change gets noticed at all — essential reading for anyone who's ever debugged a view that wouldn't update, or updated when it had no reason to. 📍Level: Intermediate Some Things Are Never Truly LostAfter an errant 📍Level: Beginner Headless Xcode: From Prompt To Simulator With MCPArtem Novichkov drives Xcode and the iOS Simulator entirely through an MCP server and prompts — no clicking required — treating the toolchain as a scriptable interface instead of a GUI you have to operate by hand. 📍Level: Advanced This Week in Those Who Swift 🗞️The latest across Swift, Apple, AI, and the community. Swift Around the Web 🌐Trailing Commas Beyond Arrays In Swift 6.1Sarun Wongpatcharapakorn covers how Swift 6.1 extends trailing-comma support past arrays to parameter lists, tuples, and generics — a small change that quietly makes every future code review and diff cleaner. 📍Level: Beginner Beta Preview: LazyStatePoint-Free previews LazyState, a library that picks up where WWDC's new 📍Level: Advanced Coding 👨💻Why Swift Is Introducing A Warning For Weak Captures Within Nested ClosuresJohn Sundell explains a new Swift compiler warning that catches a specific, easy-to-miss closure-capture mistake — and why "just add [weak self]" turns out not to be automatically enough once closures start nesting. 📍Level: Intermediate Building A Reusable HTTP Client In Swift With async/awaitMohammad Azam builds a typed, testable networking layer from scratch on async/await — a solid reference the next time you're tempted to reach for a third-party networking library instead. 📍Level: Intermediate Dynamically Setting Accessibility Custom Content Pairs In SwiftUIBas Broek shows how to attach and dynamically update multiple accessibility custom content entries on a view, so VoiceOver users get more than one flattened description of what's on screen. 📍Level: Intermediate Apple 🍏Surprise And ShineApple announced a September 9, 2026 event, widely expected to headline the iPhone 18 Pro lineup. Nothing developer-facing has shipped yet, but it's the date to have on your radar. Update: New Domain For Sign In With AppleApple reversed a planned domain change for Sign in with Apple and iCloud+ Hide My Email after developer and user pushback — the current domain stays in place. AI & Tooling 🤖Getting Into Flow With AI CodingNatasha makes the case that AI-assisted coding can deepen flow state rather than break it — if you stay actively involved: breaking work into small commits, and doing the planning and reviewing yourself instead of handing that over too. 📍Level: Intermediate Claude Code Rules, Hooks And Skills, And How I Set Mine UpRoland Leth breaks down Claude Code's three configuration layers — rules, skills, and hooks — and how they differ: preferences you state versus procedures you define versus safeguards that get enforced whether the AI "remembers" them or not. 📍Level: Intermediate Design🎨Building An Accessible Calendar Chart With Swift ChartsMatthaus Woolard builds a calendar-style chart with Swift Charts that also works with VoiceOver — treating accessibility as part of the chart's design from the start rather than a pass added at the end. 📍Level: Intermediate Tutorials 📒Uploading To TestFlight From The Command LineKyle Browning walks through scripting a TestFlight upload without opening Xcode — a useful building block for anyone trying to get release day off a human's clipboard and onto CI. 📍Level: Intermediate Fix Sluggish SwiftUI Previews Instantly With Static Mock DataSagar Unagar shows a quick technique for keeping Xcode previews fast: swap live or expensive data sources for static mocks so iterating on a view doesn't mean waiting on a network call every time. 📍Level: Beginner Community🤝SE-0541: Flexible Swift/C Interoperability For PackagesThe Swift Evolution community accepted SE-0541, giving Swift packages more flexible ways to interoperate with C code — a small but real ecosystem win for anyone bridging C libraries into Swift. 📍Level: Advanced Thanks for reading Those Who Swift! Subscribe for free to receive new posts. 👇
|
