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 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

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

RE: https://hachyderm.io/@pointfreeco/116331137317592772

So, so excited to be digging into these betas tomorrow!
@pointfreeco is one of the best investments you can make in your ongoing career as an iOS engineer, and I’m so excited to see both TCA 2, and to dig into DebugSnapshots for exhaustive testing for reference types!

@pointfreeco 🫨🫨🫨

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

Mutex improves on OSAllocatedUnfairLock in two ways:

• It is more flexible by using the 'sending' keyword to safely pass non-sendable objects in and out
• It is more strict since there is no lock() or unlock() method

Learn all about it:
https://www.pointfree.co/episodes/ep360-isolation-mutex

Loving the latest @pointfreeco series on isolation in Swift. It’s excellent to see how to use locks safely, that they should *not* be used absolutely everywhere, and that Sendable should be applied surgically and precisely.
Excited to see how this affects TCA 2, and how to write safer, more performant concurrent Swift code!

We explore the most modern locking primitive in Swift: Mutex. It has some serious smarts when it comes to protecting nonsendable state across threads in a synchronous manner, but it also has a serious bug that you should be aware of.

👉 https://www.pointfree.co/episodes/ep360-isolation-mutex

OSAllocatedUnfairLock has two initializers: one requires Sendable, the other is unchecked. A 3-line extension using @‌Sendable @‌autoclosure gives you a safe way to protect non-sendable state.

Learn this trick and more in this week's episode: https://www.pointfree.co/episodes/ep359-isolation-osallocatedunfairlock

Have you tried SQLiteData yet?

https://github.com/pointfreeco/sqlite-data

OSAllocatedUnfairLock ships two initializers: one too strict (requires Sendable), the other unchecked. A 3-line extension using @‌Sendable @‌autoclosure gives you a safe middle ground for non-sendable state.

Learn this fun trick in this week's episode: https://www.pointfree.co/episodes/ep359-isolation-osallocatedunfairlock

NSLock was built before Swift concurrency so its API has no sendability annotations, making it easy to write unsafe code.

OSAllocatedUnfairLock is a modern replacement that uses sendability to express that you cannot capture nor return non-sendable state from it.

Learn all about this in our "Swift Isolation" super series: https://www.pointfree.co/episodes/ep359-isolation-osallocatedunfairlock

Some hard data on a successful conversion of a Core Data app to SQLiteData. Crashes go 📉

iCloud collaboration is a major selling point for apps, so don't leave that functionality on the ground!

SQLiteData makes it incredibly easy for your users to share records with other iCloud users. It truly only takes a few minutes to implement!

👉 https://github.com/pointfreeco/sqlite-data

NSLock and OSAllocatedUnfairLock both have a 'withLock' method, but they are completely different.

The former is mere sugar around lock+unlock, and the latter actually protects state by wrapping it and using sendability attributes.

See how this distinction helps prevent data races:
https://www.pointfree.co/episodes/ep359-isolation-osallocatedunfairlock

You might think @‌unchecked Sendable is a localized escape hatch, but it opens the floodgates for data races in unrelated code.

This week we show how it caused a crash in a completely different class that was never marked as unchecked sendable. How??

https://www.pointfree.co/episodes/ep359-isolation-osallocatedunfairlock

Isolating state with an NSLock is not as straightforward as it seems, and we showed a subtle data race. But Apple provides a more modern tool that helps prevent this data race at compile time. Let’s take it for a spin and understand how it works.

👉 https://www.pointfree.co/episodes/ep359-isolation-osallocatedunfairlock

A novel use of SwiftPM traits can strike a nice balance between soft and hard deprecations, giving users a friendly migration path towards major breaking changes. We explore this concept in the context of our upcoming Composable Architecture 2.0 release.
https://www.pointfree.co/blog/posts/203-hard-deprecations-and-soft-landings-with-swiftpm-traits

Big release for Snapshot Testing: full support for Swift Testing attachments!

🎉 https://github.com/pointfreeco/swift-snapshot-testing/releases/tag/1.19.0