Point-Free offers some of the most advanced and original Swift content out there. It will help you bring your expertise of the Swift language to the next level, and starting today we’re having a Black Friday sale, which gives you 30% off the first year of your subscription.

Once subscribed you’ll get instant access to all 304 episodes of original Point-Free content. This includes popular collections that were created or expanded this year, as well as all of the material we have planned for 2025! Here are just a few of our additions from this year:

This year we began a new type of episode arc on Point-Free called “Back to Basics”. In these episodes we will break down a foundational concept in Swift into its simplest components so that we can achieve an expert understanding of the topic. We began with a seemingly simple subject: the Equatable and Hashable protocols in Swift.

However, looks can be deceiving. These protocols are not like most other protocols in the language. They have a very formal, mathematical specification, and if your implementation runs afoul of its semantics you will be in for a world of hurt. Reasonable looking code will have very unreasonable behavior. Watch this series to gain a deep understanding of how these protocols are meant to be used.

At the end of the year we turned our attention to advanced topics in data persistence, starting with an introduction to SQLite. Thanks to Swift’s wonderful interoperability with C, we get immediate access to everything SQLite has to offer. Our series serves as a crash course in calling C libraries from Swift, including dealing with pointers, as well as the basics of what SQLite has to offer.

After covering the basics of the SQLite C library we move onto a more modern way of dealing with SQLite in Swift projects by exploring the GRDB library by Gwendal Roué. This library provides a modern Swift interface over the SQLite C library, and gives one easy and safe access to some of SQLite’s most advanced functionality.

This is our personal favorite series from the year. We explored what Swift looks like on platforms other than Apple’s. The primary platform we explored is WebAssembly (Wasm) where we show how to build a Swift application that runs in a web browser. The application involves complex side effects (timers, networking, persistence) as well as navigation (alerts and modals), and it’s built in 100% pure, cross-platform Swift. This means that with a little bit of extra work the application could be further ported to Windows, Linux, and beyond!

And while this series may seem like it is merely about writing code that runs in the browser, the true impetus of this series is to explore advance domain modeling techniques. By writing the logic and behavior of your features in a way that is quarantined from view-related concerns we instantly unlock the ability to run that features in a variety of mediums. It doesn’t take much work to do, but the payoffs are huge.

Most people didn’t expect us to dedicate a series of episodes on “Modern UIKit” in the year 2024, but that’s exactly what we did. SwiftUI may be all the rage these days, but that doesn’t mean you won’t occassionally need to dip your toes into the UIKit waters. Whether it be to access some functionality not yet available in SwiftUI, or for performance reasons (UICollectionView 😍), you will eventually find yourself subclassing UIViewController, and then the question becomes: what is the most modern way to do this?

Our “Modern UIKit” covers a variety of topics to help you modernize your usage of UIKit and get the most out of the framework. This includes how to use Swift’s powerful Observation framework with UIKit (including the @Observable macro), state-driven navigation that looks similar to SwiftUI (including stack-based navigation), and bindings for UI controls. By the end of this series we can write UIKit applications in a style that looks quite similar to SwiftUI and removes a lot of the pain when dealing with UIKit.

This year we added a powerful tool that our viewers were clamoring for, and that is sharing state amongst features in a Composable Architecture application. Sharing state in Composable Architecture applications can be tricky because the library prefers one to model domains with value types rather than reference types. The benefits of doing so are huge (no spooky actions at a distance, easy testing, …), but it does complicate sharing state since value types are copied when passed around.

So, we built a tool called @Shared that allows one to still embrace value types while getting many of the benefits of reference types. And even better, we further built the notion of persistence into @Shared so that you can also immediately persist your state in user defaults, the file system, or any storage system of your choice.

This only scratches the surface of what we covered in 2024, and we have plenty of exciting topics planned for 2025, including a new series we are calling “Modern Persistence” showing how to approach persistence in apps with modern techniques, as well as a new fundamental change to the Composable Architecture that will unlock capabilities currently impossible, and a lot more.

Be sure to subscribe today to get access to all of this and more. The offer is valid for only a few days, so you better hurry!