A blog about app development for the Apple platforms and running a company.
We have a running joke on the team. Whenever we’re fed up fighting a framework and can’t find workarounds, someone proposes sending one of us as an undercover intern to that framework’s team at Apple, to fix the bugs from within. Over the years
Those of you who follow me on Mastodon might have noticed that I recently ran into a compiler bug that was introduced in Xcode 26.5 (or more specifically, Swift 6.3.2). I was unusually late this time: I normally have the betas running, but didn’t, and
One thing I only learned after working with Structured Concurrency for years is what “structured” actually refers to. And since that came as a surprise to me, I thought others might find it interesting as well. My natural thinking was that everything inside Swift’s modern concurrency
Tasks are versatile and adapt to many use cases. The most intriguing one to me is using them as futures: starting a Task with asynchronous work and using its handle anywhere the result is needed. Because tasks are inherently thread-safe, they don’t require additional protection or synchronization. This
If you’ve been developing for Apple platforms for a while, your understanding of “concurrency” may have its origins in the era of Grand Central Dispatch . Or, if like me, you’ve been here a bit longer, maybe even pthreads . 🙈 Threads are mostly gone from
In the first post on task cancellation, I showcased a few simple examples of manual cancellation handling using Task.isCancelled and Task.checkCancellation . Using these functions is passive (or reactive) cancellation support: If your code happens to pass over such a check, it cancels. But if not, there might be
Working with cancellation in tasks is a double-edged sword. It’s great when it works, but it’s so easy to shoot yourself in the foot. Take the observerTask example from the previous post : let observerTask = Task { let notifications = NotificationCenter.default.notifications(named: name) for await next in
I’ve been diving deeper into Swift’s structured concurrency (and strict Sendability conformance) lately, and I’ve learned quite a lot. I’m writing this down to deepen my understanding—and I hope others might find it useful as well. This is the first
When working with images, we rarely need to show them at full size — most often ist’s rather as a thumbnail or preview. Using fully loaded images for this is quite slow, so we implemented a thumbnail cache. While modernizing this component, I remembered user reports about slow
I’ve been running a software company for over 22 years now, and always managed to go without a personal blog. We’ve had company blogs on and off over the years, where I wrote a thing or two, but they all faced challenges. Too little time, too
