iOS Newsletter
Hi folks,
This week’s newsletter is heavy on the UI/UX side with articles related to phase animations, performance optimizations, leveraging some private, but safe to use SwiftUI views and more.
Enjoy!
Swift
Task.sleep() vs. Task.yield(): The differences explained
Swift Concurrency allows us to use Task.sleep() and Task.yield() to let a specific task sleep or yield for a period of time. Both look and behave similarly, but there are a few significant differences to be aware of. Find out more by tapping the link above.
UI/UX
SwiftUI Phase Animation “Bug”
Here’s Chris Eidhof with a short article on dealing with SwiftUI’s phase animators. He noticed that phase animators weren’t behaving as expected, and he initially assumed that he’d found a bug in SwiftUI. It turned out that there was no bug, but another SwiftUI gotcha.
SwiftUI Performance - How to use UIKit
What many developers do when adopting SwiftUI is to build some views for their existing UIKit apps as a start. While this works, there’s a tradeoff—every UIHostingController creates its own SwiftUI environment, which means you can’t share data between them. Moreover, using UIKit for navigation and SwiftUI for some views was considered the best practice for years. Things are changing, and what may be considered best practice these days is exactly the opposite—use SwiftUI’s navigation mechanisms and rely on UIKit only when performance is critical.
Designing a custom lazy list in SwiftUI with better performance
Our apps often need to handle large datasets efficiently, but SwiftUI’s standard List can struggle with performance as the number of items grows. A common alternative is wrapping a LazyHStack in a ScrollView, but this approach also struggles with large datasets. This article goes through the process of creating a custom view with some logic to recycle its views to achieve the desired performance. While the article is heavily Mac-related, the samples can be used on iOS as well.
Secret SwiftUI: A practical use for _VariadicView
_VariadicView is a private-ish SwiftUI API, as it is the underlying implementation detail for many of the container views we use every day. Despite being an underscored “private” API, it’s safe to use in production—many @frozen SwiftUI APIs explicitly conform to the protocol. You won’t have to worry about app review when using it—the API is already emitted into your code implicitly whenever you use a SwiftUI container view like HStack.
Data
SwiftData CRUD Operations with ModelActor
ModelActor is an approach that claims to make it “much easier to work with SwiftData in a concurrent environment while maintaining the safety guarantees that Swift provides.” After reading the article, we agree — we like it a lot.
Testing
XCTest vs Swift Testing: A modern way of linking bugs
With the new Swift Testing framework, we have a special bug trait that can be passed to the @Test macro. The bug trait takes a URL String as an argument and optionally a title, allowing us to add a short description of the bug. The key advantage over a regular comment is that the bug title is visible in the test results. Better yet, tapping on it takes you directly to the related webpage with the bug report. Here’s how to use it.
Utils
Swift CMake Examples
Here’s a link to a repository that contains a number of examples for using CMake to build Swift with different project layouts. The examples include using CMake to build pure-Swift projects and projects that use Swift-C++ interoperability.