30% Off Point-Free for Black Friday!

We do this only a few times a year: we‘re having a rare, Point-Free sale this Black Friday by offering 30% off the first year of your subscription!

Once subscribed you’ll get instant access to all 259 episodes (163 hours of video and growing!) of 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 2024!

Here are just a few of our additions from this year:

Modern SwiftUI

At the beginning of the year we finished our 7-part series on what we feel it takes to build a modern SwiftUI application. We took inspiration from one of Apple’s own moderately complex demos, Scrumdinger, and we rebuilt it with a focus on domain modeling for navigation, side effects, dependencies and testing. By the end we were able to accomplish things in our code base that were not so easy in Apple’s, such as deep-linking, more cohesive previews, and simple unit testing.

We ended up open-sourcing the application we built, which we call SyncUps. We also encouraged others to share how they like to build modern, complex SwiftUI applications by rebuilding Apple’s Scrumdinger in the style of their choice, and sharing with the community.

Our Modern SwiftUI series ended long before the release of Swift 5.9’s Observation framework, and so we could not use any of those tools during the episodes. But we later had a dedicated episode to refactoring the SyncUps app to use the new @Observable macro. We found that we could delete a lot of code and simplify a lot of things, although we did run into one gnarly gotcha with the Observation framework.

Composable Architecture 1.0

After more than 3 years of development we finally released 1.0 of the Composable Architecture. To celebrate we released a 7-part series of episodes to build a moderately complex app from scratch and show how to best make use of many of the tools that come with the library.

And the app we built was directly inspired from our Modern SwiftUI series where we rebuilt Apple’s Scrumdinger application. But this time we rebuilt it with the Composable Architecture, and saw a number of benefits, including the ability to use value types for domain modeling instead of reference types, simpler composition and navigation APIs, and truly powerful and exhaustive testing.

Deep dive into @Observable

Most recently this year we dove deep into the new Observation framework in Swift 5.9 in a 4-part series:

• We showed off the past tools, pre-Observation, and demonstrated that while they got the job done there was a lot to be desired.
• Then we showed off what the new tools were capable of, and it was quite amazing. You can build your SwiftUI features in a simpler, more naive manner, and everything somehow just magically works! We even dipped our toes into the actual open source code in the Observation framework so that we could get a better understanding of how everything works.
• However, the Observation tools do have some gotchas, so we dedicated an entire episode to just that so that you can best wield the tools. Otherwise you run the risk of over-observing state or glitchy views.
• And finally we explored a theoretical future of what @Observable could look like if it were allowed to be applied to structs. There are a lot of reasons to want that, but unfortunately it’s just not quite possible in Swift today.

Reliable Async Testing

One of the best new features to be added to Swift in the past few years was concurrency. It makes complex asynchronous code short and succinct, it provides all new tools for making concurrent code safe, and it unlocks all new patterns that were previously difficult to imagine.

However, testing code involving Swift’s new asynchronous tools remained elusive. It seems the moment you introduce the async or await keyword to your code you open up Pandora’s box of non-determinism and flakiness in your code that is nearly impossible to test. You are forced to sprinkle Task.yields or Task.sleeps throughout your tests just to push things forward and assert on how your feature is behaving.

Reliably testing async code was such a problem that we started a discussion on the Swift forums to see what could be done about the situation…and unfortunately there’s not much. At least not much in the way of official tools provided by Swift.

But, over the course of 5 episodes we broken down why testing async code in Swift is so difficult, and provided a solution. We even packaged the tool up into an open-source library that can help any code base test their async code in a fast and non-deterministic manner.

Subscribe today!

This only scratches the surface of what we covered in 2023, and we have plenty of exciting topics planned for 2024, including bringing @Observable to the Composable Architecture, a new fundamental change to the Composable Architecture that will unlock capabilities currently impossible, and perhaps we will even start to explore some server-side Swift. 😀

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!