My father’s iPhone 16 suddenly stopped charging. After making an appointment, I took it to the Apple Store for repair. Once the staff confirmed the issue, they provided me with an iPhone 14 as a loaner and helped transfer the data. Twelve days later (which included a long holiday), the device was ready—the Type-C port had been replaced, along with a complimentary new battery. The experience was, as always, satisfying.
Over the years, I’ve had quite a few Apple devices repaired. Some memorable instances include: a free logic board replacement for my MacBook Pro due to the “GPU gate” issue, and a free display replacement for my 2011 27-inch iMac because of dust accumulation behind the screen. For other minor issues, if the timing was right, sometimes they’d simply replace the device entirely.
There’s no shortage of complaints online about Apple Store or authorized service providers. But personally, my repair experiences have been consistently smooth—perhaps thanks to being well-informed about the device issues and maintaining a friendly attitude throughout.
An interesting observation: there are quite a few elderly customers at the Apple Store. Chatting with Genius Bar staff, I learned that many young people pass down their old iPhones or iPads to their elders, or buy new devices as gifts, but often don’t have time to teach them how to use them. As a result, a significant portion of the Genius Bar’s workload has become helping seniors set up accounts, install apps, and learn basic operations.
The Genius Bar’s presence enables users of all ages to enjoy the convenience of technology—serving customers while strengthening brand loyalty. Today, many other brands have opened substantial retail stores, but most remain focused on display and sales. In an era where online shopping has become the norm, the value of physical stores has long transcended “selling products”—it lies in the warmth of face-to-face human interaction. This is precisely the essential appeal of the Apple Store.
Recent Recommendations
Hot Reloading SwiftUI Apps
While Xcode Preview offers great convenience for developers to instantly see UI changes, it still has many limitations. Daniel Hooper demonstrates an ingenious hot reloading solution in this article: compile the UI and app logic into a dynamic library that the host app loads at runtime. When code changes, reload the new library and replace the old one. The highlights of this approach include: support for full app execution, state preservation, and independence from Xcode. The entire implementation requires only about 120 lines of code, perfectly embodying the principle that “once you understand the fundamentals, complex features can be implemented elegantly.”
Mastering UITableViewDiffableDataSource
While SwiftUI’s list capabilities continue to improve, UITableView remains irreplaceable for scenarios involving large datasets, complex interactions, or fine-grained control. Compared to SwiftUI’s declarative simplicity, UITableView’s data source management is more error-prone, with batch updates often crashing due to data-UI inconsistencies. Kingnight (Jinkai) systematically explains the modern usage of UITableViewDiffableDataSource through a fully-featured music playlist example.
The article not only covers the basics but also deeply compares the performance trade-offs between reconfigureItems and reloadItems, dissects the implementation of drag-to-reorder and swipe-to-delete, and provides reusable architectural practices through BaseReorderableDiffableDataSource and DiffableTableAdapter. Whether integrating UIKit lists in SwiftUI projects or maintaining existing UIKit projects, this is a solid modernization guide.
iPhone 17 Screen Sizes
The iPhone 17 series brings major screen configuration changes: the Plus model is discontinued, replaced by the new iPhone Air (6.5 inches). The base iPhone 17 and Pro versions share the same 6.3-inch display, meaning the base model gets Pro-level features like ProMotion and Always-On Display for the first time. Notably, all new models add a 20pt top safe area inset in landscape mode.
Keith Harrison has compiled complete screen sizes and Safe Area Insets for all iPhones (and iPod touch) since iOS 15, and updated App Store screenshot requirements: developers can continue uploading main screenshots at 6.9” (1320×2868) or 6.5” (1242×2688) specifications.
Beyond QA: Mobile Testing Strategies
Mobile apps can’t be “hot-fixed”—once a crash goes live, you must go through review and staged rollout, making prevention far more important than remediation. Tjeerd in ‘t Veen uses the “combinatorial explosion” problem to analyze why manual testing alone is insufficient and explores how to build a more comprehensive mobile testing system.
The article weighs various testing strategies: manual testing excels at finding UI and interaction issues but doesn’t scale; UI tests can run large-scale flows in parallel but have high maintenance costs; snapshot tests capture visual regressions but require maintaining reference image libraries. The author recommends a hybrid strategy—covering 90% of functionality with unit and UI tests, using manual testing to verify real network environments and visual details, and making UI tests optional or scheduled to avoid blocking development workflows.
Automate All the Things with Swift Subprocess
Jacob Bartlett explores through multiple examples how [swift-subprocess](https://github.com/swiftlang/swift-subprocess?utm_source=fatbobman weekly issue 107&utm_medium=web)—a new library aimed at replacing the aging Process (NSTask) API with Swift’s modern features—can improve Swift scripting experience. For simple scripts, swift-subprocess remains cumbersome: requiring a full SPM project setup, with dependency resolution and compilation overhead on first run that makes one question whether this still counts as “scripting.” However, in more complex automation workflows (like CI/CD pipelines), Swift’s type safety, modularity, and maintainability shine through—less concise than Bash but better for organization and reuse.
Jacob notes that in the age of LLM-assisted programming, the marginal cost of Bash scripts is nearly zero, and LLMs’ mastery of Bash far exceeds Swift. Whether to adopt swift-subprocess should be based on actual needs rather than the ideal of “unifying all toolchains with Swift.”
Swift Concurrency: What I Wish Someone Had Told Me
Over the past six months, Bruno Valente Pimentel completed Swift 6 concurrency migration for three apps, sharing the hard-learned lessons that documentation won’t tell you. Bruno reveals several key pitfalls: @MainActor only protects synchronous access, the world after await is full of unknowns; Actor reentrancy can cause hidden race conditions requiring “task deduplication” to avoid; and obsessing over code cleanliness (forcing Sendable) slows progress—better to use @unchecked Sendable and @preconcurrency to unblock development, then pay down technical debt gradually.
The author’s insight: the goal isn’t perfection, but creating software that’s better than yesterday.
Using Rich Text in the TextEditor with SwiftUI
At WWDC 2025, Apple brought long-awaited rich text support to TextEditor, allowing developers to write and edit styled text directly using AttributedString in SwiftUI. Alfonso Tarallo demonstrates the complete workflow from basics to editing interactions (selection, attribute transformations), particularly noting the clever design of transformAttributes(in:): it handles selection as inout, automatically merging adjacent attribute fragments to avoid text fragmentation.
TextEditor’s rich text capabilities heavily depend on major enhancements to AttributedString at the Foundation level. As Jeremy emphasized in the WWDC Session, AttributedString indices are “paths through a tree”—a design that’s powerful yet complex. To truly master this feature, developers need not just to learn new APIs, but to understand an entirely new text processing paradigm.
Singletons with Swift Concurrency
Singletons, as “global mutable state,” have become a thorny issue under Swift Concurrency’s strict model. Matt Massicotte provides a pragmatic migration guide centered on the core principle of “expressing truth” to the compiler about concurrency facts.
The article systematically analyzes various approaches: if a type already has thread-safety mechanisms, use @unchecked Sendable to honestly declare it; if accessed mainly on the main thread, @MainActor is the most honest and efficient choice. While converting classes directly to actors or using custom global actors can completely isolate state, it often leads to over-engineering. Matt advises developers to explicitly tell the compiler what’s actually happening rather than hiding existing concurrency patterns, making invisible risks visible.
A Reddit discussion from a few days ago sparked heated debate, with Matt participating. This article is his systematic response to that topic, with the principle of “expressing truth” running throughout.
Tools
AsyncCombine
While Apple has clearly positioned Swift Concurrency as the future direction, many developers have experienced a decline in code readability after migrating from Combine—what were once clean reactive pipelines have become verbose for await loops and manual task management. To address this, William Lumley developed AsyncCombine, a lightweight library built on AsyncSequence and the Swift Observation framework. It preserves native async/await features while bringing back Combine-style operators, allowing developers to continue using familiar APIs like sink, assign, and store(in:) to write more intuitive, composable asynchronous code.
When dealing with complex asynchronous data flows, I still prefer Combine’s pipeline-style expression—it makes the intent of data transformations immediately clear. As William puts it in AsyncCombine: Because Async Code Shouldn’t Be Ugly: powerful functionality and elegant code are not mutually exclusive.