Recent articles

In Xcode 16, it’s possible to add custom keys using the convenient @Entry macro. Sometimes you’ll find yourself in a situation where you want to conveniently pass some object down via the SwiftUI environment. An easy way to do this is through the .environmentObject view modifier. The one downside of this view modifier and corresponding […]

A new year has started and most of us are probably figuring out what we should focus on this year. Whether it’s learning new things or expanding our knowledge on topics we’ve already learned about in the past, there’s always something that deserves our attention in the world of iOS development. In this short post […]

I’ve recently been working on a background uploading feature for an app. One of the key aspects to get right with a feature like that is to correctly handle scenarios where your app is suspended by the system due to RAM constraints or other, similar, reasons. Testing this is easily done by clearing the RAM […]

There’s a good chance that you’re using SwiftUI and that you’re not quite sure how and when SwiftUI determines which views should redraw. And arguably, that’s a good thing. SwiftUI is clearly smart enough to make decent decisions without any negative consequences. In fact, you might even have set up your app in a way […]

The biggest features in Swift 5.5 all revolve around its new and improved concurrency features. There’s actors, async/await, and more. With these features folks are wondering whether async/await will replace Combine eventually. While I overall do not think that async/await can or will replace Combine on its own, Swift 5.5 comes with some concurrency features […]

Async/await will be the defacto way of doing asynchronous programming on iOS 15 and above. I’ve already written quite a bit about the new Swift Concurrency features, and there’s still plenty to write about. In this post, I’m going to take a look at building an asynchronous image loader that has support for caching. SwiftUI […]

If you’ve worked with Combine in your applications you’ll know what it means when I tell you that you should always retain your cancellables. Cancellables are an important part of working with Combine, similar to how disposables are an important part of working with RxSwift. Interestingly, Swift Concurrency’s AsyncSequence operates without an equivalent to cancellable […]

One of my favorite concurrency problems to solve is building concurrency-proof token refresh flows. Refreshing authentication tokens is something that a lot of us deal with regularly, and doing it correctly can be a pretty challenging task. Especially when you want to make sure you only issue a single token refresh request even if multiple […]

Earlier, I published a post that shows you how to use Swift Concurrency’s task groups. If you haven’t read that post yet, and you’re not familiar with task groups, I recommend that you read that post first because I won’t be explaining task groups in this post. Instead, you will learn about a technique that […]

In last week’s post, I demonstrated how you can use a task group in Swift to concurrently run multiple tasks that produce the same output. This is useful when you’re loading a bunch of images, or in any other case where you have a potentially undefined number of tasks to run, as long as you […]