Point-Free Videos: Recent Episodes
Brandon Williams & Stephen Celis
Point-Free is a video series about functional programming and the Swift programming language. Each episode covers a topic that may seem complex and academic at first, but turns out to be quite simple. At the end of each episode we’ll ask “what’s the point?!”, so that we can bring the concepts back down to earth and show how these ideas can improve the quality of your code today.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We round out our series with one more feature: the ability for our users to manage a list of their favorite facts. It will allow us to explore a complex side effect, persistence, and show how the same Swift code can save and load data across iOS app launches _and_ web page refreshes.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We've already covered a lot of ground and could have ended the series last week, but let's do a few more things to show just how powerful cross-platform domain modeling can be by adding a _new_ feature to our cross-platform application and see just how easy it is to integrate with SwiftUI, UIKit, _and_ WebAssembly.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We will introduce UI controls and focus logic to our SwiftWasm application by leveraging abinding type inspired by SwiftUI, and we will see how similar even our view logic can lookacross many platforms.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We will introduce navigation APIs to our Wasm application, starting simply with an alert before ramping things up with a dialog tag that can be fully configurable from a value type that represents its state and actions.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---Let's dial up the complexity of our Wasm application! We'll introduce some async logic in the form of a network request. We'll take steps to not only control this dependency, but we'll do so across both Apple and Wasm platforms, and we'll isolate its interface from its live implementation to speed up our builds and reduce our app's size.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.---We are going to take a Swift feature _into the browser_. We will set up a WebAssembly application from scratch, show how to run and debug it, and even set up some basic UI. And then we will integrate our existing model into it, all powered by the magic of Swift's Observation framework.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.---It's time to go cross-platform! We will take a feature written in Swift and use it in vastly different situations, including not only SwiftUI and UIKit, but beyond Apple's frameworks and ecosystems. We will start with a baby step and introduce our feature to a third party view paradigm, Airbnb's Epoxy.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---While we rebuilt SwiftUI bindings in UIKit to power state-driven navigation, that's not all SwiftUI uses them for! Let's see what it takes to power UIControls from model bindings. And finally, let's ask "what’s the point?” by comparing the tools we’ve built over many episodes with the alternative.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We round out our stack navigation tools with support for an @Environment-like feature for holding onto the stack's path, a NavigationLink-like feature for pushing features onto the stack from anywhere, and we'll handle every corner case from deep-linking to user dismissal.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We have now implemented tree-based navigation in UIKit, driven by the Observation framework, but there is another form of navigation to think about: stack-based navigation, where you drive your navigation from a flat collection of states rather than a heavily-nested type. Let's leverage Observation to build a really nice tool for stack-based navigation.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---While SwiftUI bindings were almost the perfect tool for UIKit navigation, they unfortunately hide some crucial information that we need to build out our tools. But never fear, we can rebuild them from scratch! Let's build @Binding and @Bindable from scratch to see how they work, and we will use them to drive concise, tree-based navigation using enums.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We have built the foundation of powerful new UIKit navigation tools, but they're not quite finished. Let's improve these APIs to handle dismissal by leveraging another SwiftUI tool: bindings. We will see how SwiftUI bindings are (almost) the perfect tool for UIKit navigation, and we will see where they fall short.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---Now that we have a tool that brings the power of the Observation framework to UIKit, let's put it through the paces. We will use it to build state-driven navigation tools that can drive alerts, sheets, popovers, drill-downs, and more, and they will look a lot like SwiftUI's navigation tools.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---It's time to build modern tools for UIKit from scratch, heavily inspired by SwiftUI and usingthe Observation framework. Surprisingly, Swift 5.9's observation tools _can_ be used in UIKit,and in fact they work _great_, despite being specifically tuned for SwiftUI.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.---We finish building a modern UIKit application with brand new state-driven tools, including acomplex collection view that can navigate to two child features. And we will see that, thanksto our back-port of Swift's observation tools, we will be able to deploy our app all the wayback to iOS 13.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.---As we approach WWDC23 and 5 years of SwiftUI, let's talk about… UIKit! 😜 We love SwiftUI,but there will still be times you must drop down to UIKit, and so we want to show what modernUIKit development can look like if you put in a little bit of effort to build tools that allowyou to model your domains as concisely as possible.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We conclude the series by stretching our use of the @Shared property wrapper in isowords to two more features: saved games and user defaults. In the process we'll eliminate hundreds of lines of boilerplate and some truly gnarly code.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---Let's apply the Composable Architecture's new state sharing tools to something even more real world: our open source word game, isowords. It currently models its user settings as a cumbersome dependency that requires a lot of code to keep features in sync when settings change. We should be able to greatly simplify things with the @Shared property wrapper.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We finish refactoring the SyncUps application to use the Composable Architecture's all new state sharing tools. We will see that we can delete hundreds of lines of boilerplate of coordination between parent and child features, _and_ we we won't have to sacrifice any testability, including the _exhaustive_ testability provided by the library.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---In our last series we developed a wonderful way to share state between features in the Composable Architecture, and even persist it, all without sacrificing testability, but we also didn't get to show the (just now released) tools being used in real world applications, so let's do just that, starting with SyncUps.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---It's incredible how easy @Shared makes it to persist complex data types to the file system, but currently it completely ruins our ability to test features that use it. Let's fix that, and we will also explore what it means to derive a small piece of shared state from a bigger piece of shared state.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---While user defaults is convenient for persisting simple bits of state, more complex data types should be saved to the file system. This can be tricky to get right, and so we take the time to properly handle all of the edge cases.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We can now persist simple bits of state to user defaults using the @Shared property wrapper, but there is more work to be done. We need to observe changes to user defaults in order to play those changes back to @Shared, and we need to put in a bit of extra work to make everything testable.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---Let's enhance the @Shared property wrapper with the concept of persistence. We will begin with user defaults, which is the simplest form of persistence on Apple's platforms, and that will set the stage for more complex forms of persistence in the future.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We conclude the series by adding the final bit of functionality to our application: persistence. We'll see how adding a dependency on persistence can wreak havoc on previews and tests, and all the benefits of controlling it.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We introduce a complex dependency to the record meeting screen: speech recognition. We will begin to integrate this dependency into our app's logic, and show how to control it for Xcode previews and tests
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We'll learn how to precisely model navigation in the Composable Architecture using an enum to eliminate impossible runtime states at compile time. And we'll begin to implement the app's most complex screen and most complex dependency: the record meeting view and the speech client.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We show how to add stack-based navigation to a Composable Architecture application, how to support many different kinds of screens, how to deep link into a navigation stack, and how to write deep tests for how navigation is integrated into the application.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
With the standups list and standup form features ready, it's time to integrate them together using the Composable Architecture's navigation tools. We will make it so you can add and edit standups via a sheet, and write comprehensive unit tests for this integration.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We continue our tour of the Composable Architecture 1.0 by rebuilding one of Apple's most complex sample projects: Scrumdinger. We will create our own "Standups" app using the tools of the Composable Architecture.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
The Composable Architecture has reached a major milestone: version 1.0. To celebrate this release we are doing a fresh tour of the library so that folks can become comfortable building applications with it in its most modern form. We will start with a simple, but substantial application that shows off the basics, before we recreate Apple's most complex sample project.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
What's the point of the work we did to make async testing reliable and deterministic, and are we even testing reality anymore? We conclude our series by rewriting our feature and tests using Combine instead of async-await, and comparing both approaches.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We continue our deep dive into advanced Swift concurrency by exploring the concept of "executors" to better understand its global enqueue hook. We will then put this hook to work and finally have reliable, 100% deterministic async tests.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We dive into Apple's Async Algorithms package to explore some advanced usages of Swift's concurrency runtime, including a particular tool we can leverage to bend the will of async code to our advantage in tests.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We explore a few more advanced scenarios when it comes to async code—including cancellation, async sequences, and clocks—and how difficult they are to test.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
While Swift provides wonderful tools for writing async code, there are gaps in its tools for testing it. Let's explore the tools it does provide to show where they succeed, and where they fall short.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We complete the series by writing a comprehensive test suite for our stack navigation-basedapp. We will uncover some shortcomings of the tools we've built and address each one,resulting in a set of tools that are a joy to test with.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We round out the functionality of the Composable Architecture's stack navigation tools. This includes automatic cancellation of a child feature's effects when it's popped off the stack, and the ability for a child feature to pop itself. Along the way we will clean up the domain modeling and user experience of working with these tools.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We introduce a complementary StackState wrapper to our navigation tools to solve a fewissues that came from repurposing the identified array type. Once implemented and integrated,we will put these tools' superpowers to work by implementing two new features.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We begin designing brand new navigation stack tools for the Composable Architecture to solve all of the problems we encountered when shoehorning stack navigation into the existing tools, and more.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---Let's insert a new feature into the navigation stack. We'll take things step-by-step, employing an enum to hold multiple features in a single package, and making small changes to how we use our existing APIs before sketching out all-new tools dedicated to stack navigation.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We enhance our navigation stack with a bit more complexity by adding the ability to drill down multiple layers in multiple ways: using the new navigation link API, and programmatically. We also prepare a new feature to add to the stack.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---It's finally time to tackle navigation stacks in the Composable Architecture! They are apowerful, new tool in SwiftUI and stray a bit from all the other forms of tree-basednavigation we've explored. Let's compare the two styles and see what it takes to integratestacks into the library's navigation tools.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We take a detour to learn about the stack, the heap, copy-on-write, and how we can use this knowledge to further improve our navigation tools by introducing of a property wrapper.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We now support many different forms of navigation in the Composable Architecture, but if used naively, they open us up to invalid states, like being navigated to several screens at a time. We’ll correct this with the help of Swift's enums.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---While we just tackled drill-down navigation, sadly the API we used was deprecated in iOS 16. Let's get things working with the new navigationDestination view modifier, and see what testing in the Composable Architecture has to say about navigation.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We have a single navigation API powering alerts, dialogs, sheets, popovers, and full screen covers, but what about the prototypical form of navigation, the one that everyone thinks of when they hear "navigation"? It's time to tackle links.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---Let's prepare to delete a lot of code. The navigation APIs we've built so far to drive alerts, dialogs, and sheets all have more or less the same shape. We can unify them all in a single package that can also be applied to popovers, fullscreen covers, and more!
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We add superpowers to the navigation tools of the [Composable Architecture][tca-gh], includingautomatically cancelling a child feature's effects upon dismissal, and even letting childfeatures dismiss themselves! Plus, we look at how "non-exhaustive" testing simplifiesnavigation-based tests.[tca-gh]: http://github.com/pointfreeco/swift-composable-architecture
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We tackle a more complex form of navigation: sheets! We'll start with the tools the ComposableArchitecture ships today before greatly simplifying them, taking inspiration from the tools webuilt for alerts and dialogs.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---Let's dip our toes into the new composable navigation tools by improving how alerts andconfirmation dialogs can used in the library. We will create a new reducer operator that morecorrectly handles the logic and hides unnecessary details.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---It's finally time to tackle navigation in the Composable Architecture. We'll port theInventory app we first built to understand SwiftUI navigation, which will push us tounderstand what makes the architecture "composable," how it facilitates communication betweenfeatures, and testing.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.---Our first ever livestream! We talk about a few new features that made it into ourDependencies library when we extracted itfrom the Composable Architecture, live code our way through a NavigationStack refactor ofour Standups app, and answer your questions alongthe way!
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We conclude the series by taking control of the last two dependencies: persistence and speech recognition. We'll make use of even more features of our new Dependencies library and we'll write tests for our features that would have been impossible before.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---Uncontrolled dependencies can wreak havoc on a modern SwiftUI code base. Let's explore why, and how we can begin to control them using a brand new library.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We wrap up the "record meeting" screen by implementing two more side effects: speech recognition, and persistence. We'll experience the pitfalls of interacting directly with these dependencies, and why we should care about controlling them.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---After a brief digression to explore the performance and ergonomics of identified collections, we dive into the messy world of side effects by implementing the "record meeting" screen. We'll start with the timer, which has surprisingly nuanced logic.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We add more screens and more navigation to our rewrite of Apple's Scrumdinger, including the standup detail view, a delete confirmation alert, and we set up parent-child communication between features.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.---We begin to layer on behavior in our rewrite of Apple's "Scrumdinger" demo application, starting with navigation. We will do some upfront work to model it in our application state, as concisely as possible, to avoid a whole class of bugs, unlock deep linking, and enable testability.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
What goes into building a SwiftUI application with best, modern practices? We’ll take a look at Apple’s “Scrumdinger” sample code, a decently complex app that tackles many real world problems, get familiar with how it's built, and then rewrite it!
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
When all-new SwiftUI navigation tools were announced at WWDC, the one that got the most attention by far was NavigationStack, which powers navigation with an array. It is extremely powerful, but comes with trade-offs and new complexities.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Why did Apple scrap and reinvent SwiftUI’s navigation APIs in iOS 16? Let’s look at some problems the old APIs had, how one of the new APIs solves one of them, and how we can work around a bug in this new API.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
A year ago we dove deep into the topic of navigation in SwiftUI. Then Apple deprecated many of those APIs at this year's WWDC, replacing them with a brand new suite. To make sense of these changes, let's recap what we built over those past episodes, and why.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
With "immediate" and "unimplemented" conformances of the Clock protocol under our belt, let's build something more complicated: a "test" clock that can tell time when and how to flow. We'll explore why we'd ever need such a thing and what it unlocks.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
The Clock protocol is a brand-new feature of Swift 5.7 for dealing with time-based asynchrony. We will explore its interface, compare it to Combine's Scheduler profile, and see what it takes to write and use our own conformances.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
We celebrate the release of the Composable Architecture's new reducer protocol and dependency management system by showing how they improve the case studies and demos that come with the library, as well as a larger more real-world application.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Testing is a top priority in the Composable Architecture, so what does the reducer protocol and new dependency management system add to testing features? It allows us to codify a testing pattern directly into the library that makes our tests instantly stronger and more exhaustive.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We now have a SwiftUI-inspired system for plucking dependencies out of thin air to provide them to reducers, but we can’t control them or separate interface from implementation. Once we do, we’ll have something far better than ever before.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We begin to flesh out a new story for dependencies in the Composable Architecture, taking inspiration from SwiftUI. We will examine SwiftUI's environment and build a faithful reproduction that provides many of the same great benefits.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
The new reducer protocol has improved many things, but we’re now in an awkward place when it comes to defining them: some are conformances and some are not. We’ll fix that with inspiration from SwiftUI and the help of a new protocol feature.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We are already seeing huge benefits from the reducer protocol, but one aspect is still not ideal, and that is how we compose reducers. We will look to result builders to solve the problem, and a new feature of them introduced in Swift 5.7.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Let's begin to solve a number of the problems with the Composable Architecture by introducing a reducer protocol. We will write some common conformances and operators in the new style, and even refactor a complex demo application.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
The Composable Architecture was first released over two years ago, and the core ergonomics haven't changed much since then. It's time to change that: we are going to improve the ergonomics of nearly every facet of creating a feature with the library, and make all new patterns possible.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
This week we are releasing the biggest update to the Composable Architecture since its first release over 2 years ago, bringing more of Swift's modern concurrency tools to the library. To celebrate we will demonstrate how these tools can massively simplify a few real-world applications.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We explore ways to tie the lifetime of an effect to the lifetime of a view, making it possible to automatically cancel and tear down work when a view goes away. This unexpectedly helps us write even stronger tests for our features.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We introduce another helper to the Effect type that can use an asynchronous context to send multiple actions back into the system. By leveraging Swift's structured concurrency we can create complex effects in a natural way, all without sacrificing testability.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We can now run async work directly in a reducer's effects, but time-based asynchrony, like Task.sleep, will wreak havoc in our tests. Let's explore the problem in a new feature, and see how to recover the nice syntax of modern timing tools using a protocol from the past: Combine schedulers.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
This week we start fixing the problems we outlined last week. We build the tools necessary to start using concurrency tasks directly in reducers, and along the way we open Pandora's box of existential types to solve some mind-bending type issues.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
The Composable Architecture's fundamental unit of effect is modeled on Combine publishers because it was the simplest and most modern asynchrony tool available at the time. Now Swift has native concurrency tools, and so we want to make use of those tools in the library. But first, let's see what can go wrong if we try to naively use async/await in an existing application.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
There are amazing features of Swift concurrency that don't quite fit into our narrative of examining it through the lens of past concurrency tools. Instead, we'll examine them through the lens of a past programming paradigm, structured programming, and see what is has to say about structured concurrency.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
When working with concurrent code, you must contend with data synchronization and data races. While the tools of the past made it difficult to reason about these issues, Swift's new tools make it a breeze, including the Sendable protocol, @Sendable closures, and actors.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Let’s look at what the future of concurrency looks like in Swift. A recent release of Swift came with a variety of tools with concurrency. Let's examine its fundamental unit in depth, and explore how they "cooperate" in your applications.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Before developing Swift's modern concurrency tools, Apple improved upon threads with several other abstractions, including operation queues, Grand Central Dispatch, and Combine. Let's see what these newer tools brought to the table.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
To better understand Swift's concurrency tools, let's first look to the past, starting with threads. Threads are a tool most developers don't reach for these days, but are important to understand, and the way they solve problems reverberate even in today's tools.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
We conclude our tour of swift-parsing with a look at how URL routers defined as parser-printers can be automatically transformed into fully-fledged API clients, which we will drop into an iOS application and immediately use.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
Now that we're familiar with swift-parsing's URL router, let's take a look at Swift's most popular web framework, Vapor. We will rebuild our site router using Vapor's built-in router, and then we'll use our own companion library to power our Vapor application with a parser-printer, instead.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
URL routing is a large problem that has been solved in various ways over the years...but what does that have to do with swift-parsing!? A lot! swift-parsing comes with a URL routing library built on top of parser-printers, and it solves a lot of problems that still exist in today's most popular web frameworks.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
We continue our tour by comparing swift-parsing to Apple's forthcoming Regex DSL. After taking a look at the proposal, we'll translate an example over to be a parser-printer to compare and contrast each approach.
Every once in awhile we release a new episode free for all to see, and today is that day! Please enjoy this episode, and if you find this interesting you may want to consider a subscription https://www.pointfree.co/pricing.
Today we celebrate a huge release of swift-parsing, which includes the ability to build invertible parser-printers with ease. We'll demonstrate by using the library to build three different parser-printers, starting with a fun exercise from Advent of Code
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We conclude our series on invertible parsing by converting a more complex parser into a parser-printer, and even enhance its format. This will push us to think through a couple more fun parser-printer problems.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We've had to really stretch our brains to consider what it means to reverse the effects of parsing, but let's looks at some parsers that take it to the next level. They will force us to reconsider a fundamental part of printing, and will make our printers even more powerful.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Our parser-printer library is looking pretty impressive, but there are a couple problems we need to address. We have made some simplifying assumptions that have greatly reduced the generality our library aspires to have. We will address them by abstracting what it means for an input to be parseable _and_ printable.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We will chip away at more and more parser printer conformances, some of which will truly stretch our brains, but we will finally turn our complex user CSV parser into a printer!
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Now that we've framed the problem of printing, let's begin to tackle it. We will introduce a Printer protocol by "reverse-engineering" the Parser protocol, and we will conform more and more parsers to the printer protocol.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
We've spent many episodes discussing parsing, which turns nebulous blobs of data into well-structured data, but sometimes we need the "inverse" process to turn well-structured data back into nebulous data. This is called "printing" and can be useful for serialization, URL routing and more. This week we begin a journey to build a unified, composable framework for parsers and printers.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Let's make errors a pleasure to encounter! We will make them easy to read, add more context to make them easy to debug, and even see how error messages can influence existing APIs.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Let's explore the topic of error handling. We will scrutinize how we model errors in our parsing library and the problems that have come out of it, and we will address these problems by changing the fundamental shape of the parser type.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
So what is the point of parser builders anyway? We will leverage our new builder syntax by rewriting a couple more complex parsers: a marathon parser and a URL router. This will lead us to not only clean up noise and tell a more concise parsing story, but give us a chance to create brand new parsing tools.
Subscriber-Only: Today's episode is available only to subscribers. If you are a Point-Free subscriber you can access your private podcast feed by visiting https://www.pointfree.co/account.
Let's begin to layer result builder syntax on top of parsing. To get our feet wet, we will build a toy result builder from scratch. Then, we will dive much deeper to apply what we learn to parsers.