mastodon 4.7.3A video series exploring Swift and functional programming. Hosted by @mbrandonw@hachyderm.io and @stephencelis@hachyderm.io.
SwiftData has a brand new sectionBy API, for grouping the results of a @Query into sections. So what is SQLiteData’s solution to this problem? Well it turns out SQLiteData’s tools supported sectioning from day one, and much more. We’ll show just how far these tools can take use before introducing an ergonomic API to match SwiftData’s.
https://www.pointfree.co/episodes/ep374-wwdc26-sqlitedata-sectioning
Many folks avoid actors due to a proliferation of “awaits” that can introduce subtle race conditions as multiple threads can interleave and access the actor’s data.
But did you know you can squash many “awaits” down to a single one, eliminating race conditions in the process?
We compare SwiftData’s new features with SQLiteData, starting with a domain modeling exercise. We will rewrite the Trips @Model classes into simple @Table structs, and we will explore how the Draft type can power a single form for both creating and updating trips.
https://www.pointfree.co/episodes/ep373-wwdc26-sqlitedata-domain-modeling
We just made another one of our WWDC26 videos free!
Learn about what’s new in UIKit and how the UIKitNavigation library extends the framework with bindings and state-driven navigation to help you to model your domains concisely.
This week we showed off just how short and succinct our query builder can be. Need a single query that filters all/business/personal trips and sorts by trip end date, start date or name?
It all fits in just a few lines of code:
https://www.pointfree.co/episodes/ep374-wwdc26-sqlitedata-sectioning
This week we got to show off how short and succinct our query builder can be. Want a single query that can filter all/business/personal trips and sort by trip end date, start date or name?
It all fits in just a few lines of code:
https://www.pointfree.co/episodes/ep374-wwdc26-sqlitedata-sectioning
What’s better than SwiftData class inheritance? SQLiteData enums!
Model your data using simple value types that can exhaustively and concisely describe valid state at compile time.
AppleOS 27 brings a few new tools to UIKit, but our UIKitNavigation library has all of this and more:
✅ Modern alert API
✅ State-driven navigation
✅ Concisely modeled domains
✅ Animations and transactions
✅ Back-ported to iOS 13
Check it out: https://www.pointfree.co/collections/wwdc/wwdc-2026/ep371-wwdc26-uikit
SwiftData’s new “sectionBy:” API is super cool, but did you know SQLiteData supported sectioning from day one?
You have always had the ability to @Fetch your data into whatever shape you want. Here we use swift-collections’ OrderedDictionary to group results:
Our query builder has some super powers built in. Look how short and succinct it can be when querying for all/business/personal trips, sorted by trip end date, start date or name!
All of it fits in only a few lines of code: https://www.pointfree.co/episodes/ep374-wwdc26-sqlitedata-sectioning
WWDC 26 brought some updates to how UIKit interacts with Observable models, but the tools fall short on animation and granularity.
This week we show off a tool that allows one to animate UIKit views in a SwiftUI-like fashion, and with minimal observation!
https://www.pointfree.co/episodes/ep371-wwdc26-uikit
This is shaping up to be the most advanced content out there about isolation in Swift. After setting the stage with legacy tools, we show how actors are a fundamental shift in how one protects mutable data.
And we still have a lot to cover!
In celebration of WWDC26, we are making our video on SwiftUI’s new alert API free!
Get a history lesson on alerts in SwiftUI over the years, learn about efficient domain modeling, and how a lightweight package can take things even further.
This week we are making use of the fantastic package-benchmark project for benchmarking Swift code. It helps you avoid many common pitfalls of benchmarks, such as not running in release, not warming up your code paths, and focusing only on wall time.
It's easy to write a naive benchmark that “proves” actors are 25-50% slower than locks. But such benchmarks hardly ever tell the full story and can be very misleading.
We attack this thorny problem head on in this week's episode.
https://www.pointfree.co/episodes/ep364-isolation-performance
SQLiteData’s @Table macro employs some pretty advanced tricks to surface the best possible failure diagnostics and fix-its.
It’s very common for macro errors to be buried in macro-generated code, but it doesn’t have to be this way!
See this trick in action in this week’s video: https://www.pointfree.co/episodes/ep373-wwdc26-sqlitedata-domain-modeling
We are announcing something BIG today!
We’re releasing ComposableArchitecture 2.0 as a Beta Preview, as well as a brand new library: https://www.pointfree.co/beta-previews
Read all about it in our announcement: https://www.pointfree.co/blog/posts/204-introducing-point-free-beta-previews
Composable Architecture 2.0 and SQLiteData work together like salt and pepper. You treat persisted models as simple values that live in your feature’s state, something that just isn’t possible in SwiftData.
And all of TCA’s powerful testing tools just work! You play a script of user actions to your feature and get to exhaustively test how your feature changes over time by describing it in simple mutations.
Watch our preview of these tools today: https://www.pointfree.co/episodes/ep356-beyond-basics-superpowers
What’s new this year in SwiftData? We dive deep into each topic to figure out what exactly to figure out what exactly is new, what are the gotchas, and prepare for a lesson on how to best model your domains concisely.
Naive benchmarks may suggest actors lag mutexes and locks, but these constructs just aren’t apples-to-apples:
• Actor suspension is much gentler on the CPU than the act of acquiring a lock
• Actor suspension points are more easily squashed than “withLock”
Watch us build a benchmark suite today: https://www.pointfree.co/episodes/ep364-isolation-performance
WWDC brought more adoption of the Observation framework to UIKit, but more can be done.
We will employ our UIKitNavigation library to show how we can add SwiftUI-like navigation and controls to a UIKit feature, including animations and transactions.
Swift’s concurrency system has serious smarts: 6 “awaits” are squashed down to just 3 jobs enqueued when the scheduler sees it can avoid a hop. We can verify by creating a custom executor that logs whenever the actor enqueues a job.
We dive deep into the topic in this week’s video. Watch today: https://www.pointfree.co/episodes/ep362-isolation-actor-enqueuing
Actors eliminate data races at compile time, but they do not eliminate “race conditions.”
Every “await” in an actor is an opportunity for work to interleave across multiple threads, and bugs!
So we should strive to minimize suspension points in transactional code.
Learn how to fix these race conditions in this week’s video: https://www.pointfree.co/episodes/ep362-isolation-actor-enqueuing
Actors seem to force us into asynchrony, but it doesn’t have to be this way. We will show how to squash many awaits down to a single one, and we will use “serial executors” to better understand how an actor enqueues work behind the scenes.
👉 https://www.pointfree.co/episodes/ep362-isolation-actor-enqueuing
What is “isolation” in Swift? And why does understanding it matter? It turns out many frustrations developers encounter in Swift concurrency evaporate when they internalize the concept.
These videos are going to go beyond basics, so let’s get into it: https://www.pointfree.co/episodes/ep357-isolation-what-is-it
Which code do you want to maintain?
Do you really want to go through 'withLock' every time you need to access state? Wouldn't it be better to just get synchronous access to your state with no ceremony?
That's what actors give us!
https://www.pointfree.co/episodes/ep361-isolation-actors
Swift actors allow “reentrancy,” which avoids deadlocks but does open you up to the possibility of race conditions.
This is in stark contrast to other major actor implementations, including Erlang, Scala, and C#, which all ban reentrancy.
Learn why this this week’s video: https://www.pointfree.co/episodes/ep363-isolation-actor-reentrancy
Next week we will explore the concept of “actor re-entrancy”—how Swift actors approaches the problem vs. other languages and libraries, and the “wrong” way to use actors in Swift.
Catch up before then!
Have you tried SQLiteData yet?
Swift’s ownership tools don't just help our users. They also help us as library authors to keep us honest. When we lend a precious resource to a user’s closure, we wrap it in ~Escapable so it can’t outlive that closure.
Learn more:
https://www.pointfree.co/episodes/ep356-beyond-basics-superpowers
Wall time isn't the only important metric when benchmarking. CPU time is also important!
In this benchmark for high concurrency, the actor has worse wall time than Mutex but better CPU time. This means the mutex adds more contention to the cooperative thread pool than the actor.
Learn more about these nuances in this week's episode: https://www.pointfree.co/episodes/ep364-isolation-performance
Actors finally enter the stage in our series exploring “isolation” in Swift. We will compare actors to locking and mutexes to find they are a breath of fresh air (mostly). Learn why: https://www.pointfree.co/episodes/ep361-isolation-actors
Let's explore some of the misinformation about actors and performance. A common complaint is that actors are slower than locks, and so best to avoid them. These comparisons usually aren’t fair, and sometimes actors can be more performant than locks.
👉 https://www.pointfree.co/episodes/ep364-isolation-performance
We have a data race on our hands, which is exactly what Swift concurrency is supposed to solve for. Let’s figure out how we managed to get into this mess, and then we will get our feet wet with an isolation tool that predates Swift concurrency: locking.
https://www.pointfree.co/episodes/ep358-isolation-legacy-locking
Not all interactions with actors require suspending to interact with them.
We designed two actors for isolating Bank and Account data, but we make them share the same executor. This allows the actors to communicate with each other synchronously, and solves a reentrancy problem.
Get all the details:
https://www.pointfree.co/episodes/ep363-isolation-actor-reentrancy
You may wonder why it took us 5 episodes in our “Isolation” series to get to actors, but we needed to understand locks first. There's some misunderstanding in the Swift community about how actors compare to locks, and we want to clear the air.
Sendability errors in Swift might make you wonder if you should be adding “Sendable” to all your types. It seems innocent enough, and don’t we want all our types to be concurrency-safe?
The answer: an emphatic NO!
Take great care making a type sendable. Rules of thumb:
• Simple value that will never hold non-sendable data Good candidate.
• Generic type? Might want conditional sendability.
• Encapsulated data that MUST cross isolation? You might have no choice.
Learn why: https://www.pointfree.co/episodes/ep360-isolation-mutex
Swift’s ownership tools are not only for library users. They also help authors stay disciplined. When we lend a valuable resource to a user’s closure, we wrap it in ~Escapable so it cannot live longer than that closure.
Get all the details here: https://www.pointfree.co/episodes/ep356-beyond-basics-superpowers
After naively introducing a new Account actor to fix an isolation problem we caused a reentrancy problem. The fix is to share the executor between the Bank and Account actors to allow them to communicate synchronously.
Pretty amazing to see: https://www.pointfree.co/episodes/ep363-isolation-actor-reentrancy
We explore actor “reentrancy” and how adding async to actor methods open you up to race conditions. This problem also shows up when naively communicating between actors, but we can make actor communication completely synchronous.
👉 https://www.pointfree.co/episodes/ep363-isolation-actor-reentrancy
This week we learned all about how actors enqueue asynchronous work in Swift. This includes how we can minimize “awaits,” and how serial executors schedule jobs to be performed.
Watch today: https://www.pointfree.co/episodes/ep362-isolation-actor-enqueuing
The Swift proposal for actors uses a 'BankAccount' type to explore how actors work.
We think it's a bit too simplistic to really understand how actors compare to older styles of isolation, and so this week we explore a more complex example.
👉 https://www.pointfree.co/episodes/ep357-isolation-what-is-it
We have a brand new open source project we are working on, and for the first time we are giving people a very early peek.
It's a library that brings exhaustive testing tools to difficult-to-test types, such as reference types.
https://www.pointfree.co/blog/posts/205-beta-preview-debugsnapshots
Swift’s ownership tools don’t just help our users. They also help library authors keep themselves honest. When we lend a precious resource to a user’s closure, we wrap it in ~Escapable so it cannot outlive that closure.
Learn all about it: https://www.pointfree.co/episodes/ep356-beyond-basics-superpowers
In Swift 5 mode it is all too easy to write code that crashes at runtime due to simultaneously mutating some state from multiple threads.
Isolation is Swift's answer to solving this problem, and it's the focus of our newest series of episodes: https://www.pointfree.co/episodes/ep357-isolation-what-is-it
Swift's ownership tools allow us to restrict how users of our libraries interact with dangerous objects, such as a raw database pointers. They should never escape from a database transaction, and now this is enforced by the compiler.
Learn more: https://www.pointfree.co/episodes/ep356-beyond-basics-superpowers
Swift's Mutex is the modern way to lock state. It relaxes many constraints while still keeping things thread safe.
But there's a serious bug. You can escape a non-sendable object from the mutex to multiple threads and cause runtime crashes.
Learn more: https://www.pointfree.co/episodes/ep360-isolation-mutex
Our WWDC 26 collection of videos is growing, and the first episode is free!
https://www.pointfree.co/collections/wwdc/wwdc-2026
Next week we take a look at what AppleOS 27 brings to SwiftData. 🍿