Point-Free Videos
248 episodes - English - Latest episode: about 20 hours ago - ★★★★★ - 2 ratingsPoint-Free is a video series that explores advanced topics in 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.
Homepage Apple Podcasts Google Podcasts Overcast Castro Pocket Casts RSS feed
Episodes
SwiftUI Animation: The Point
March 01, 2021 06:00 - 44 minutes - 56.8 MB VideoSubscriber-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. --- Animating asynchronous effects with Combine schedulers is not only important for the Composable Architecture. It can be incredibly useful for any SwiftUI application. We will explore this with a fresh SwiftUI project to see what problems they solve and how they can allow us to better embrace SwiftUI's...
SwiftUI Animation: Composable Architecture
February 22, 2021 06:00 - 44 minutes - 57.8 MB VideoSubscriber-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 mostly "just works" with SwiftUI animations out of the box, except for one key situation: animations driven by asynchronous effects. To fix this we are led to a really surprising transformation of Combine schedulers.
SwiftUI Animation: The Basics
February 15, 2021 06:00 - 39 minutes - 39.1 MB VideoSubscriber-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. --- One of the most impressive features of SwiftUI is its animation system. Let's explore the various flavors of animation, such as implicit versus explicit and synchronous versus asynchronous, to help prepare us for how animation works with the Composable Architecture.
🆓 Concise Forms: The Point
February 08, 2021 06:00 - 28 minutes - 356 MB VideoEvery 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've shown how to dramatically streamline forms in the Composable Architecture, but it's time to ask "what's the point?" We apply the concepts previously developed to a real world application: [isowords](https://www.isowords.xyz). It's a word game built in the Compo...
Concise Forms: Bye Bye Boilerplate
February 01, 2021 06:00 - 58 minutes - 70.1 MB VideoSubscriber-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 makes it easy to layer complexity onto a form, but it just can't match the brevity of vanilla SwiftUI…or can it!? We will overcome a Swift language limitation using key paths and type erasure to finally say "bye!" to boilerplate.
Concise Forms: Composable Architecture
January 25, 2021 06:00 - 1 hour - 62.5 MB VideoSubscriber-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. --- Building forms in the Composable Architecture seem to have the opposite strengths and weaknesses as vanilla SwiftUI. Simple forms are cumbersome due to boilerplate, but complex forms come naturally thanks to the strong opinion on dependencies and side effects.
Concise Forms: SwiftUI
January 18, 2021 06:00 - 35 minutes - 329 MB VideoSubscriber-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. --- For simple forms, vanilla SwiftUI does a really good job: you can quickly build a form with many components in minimal code and boilerplate. But as a form becomes more complex, SwiftUI stops being so helpful. Let's explore the problems that emerge and how we can work around them.
🆓 Parsing and Performance: The Point
December 21, 2020 06:00 - 58 minutes - 638 MB VideoEvery 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 is well accepted that hand-rolled, imperative parsers are vastly more performant than parsers built with combinators. However, we show that by employing all of our performance tricks we can get within a stone's throw of the performance of imperative parsers, and w...
Parsing and Performance: Protocols
December 14, 2020 06:00 - 39 minutes - 35 MB VideoSubscriber-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 performance gains we have made with the parser type have already been super impressive, but we can take things even further. We will explore the performance characteristics of closures using the time profiler and make some changes to how we define parsers to unlock even more speed.
Parsing and Performance: Combinators
December 07, 2020 06:00 - 50 minutes - 29.9 MB VideoSubscriber-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 convert some of our substring parsers to work on lower levels of String abstractions, and unlock huge performance gains. Even better, thanks to our generalized parser we can even piece together multiple parsers that work on different abstraction levels, maximizing performance in the process.
Parsing and Performance: Strings
November 30, 2020 06:00 - 35 minutes - 56.5 MB VideoSubscriber-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 want to explore the performance of composable parsers, but to do so we must first take a deep dive into the Swift string API. There are multiple abstractions of strings in Swift, each with its own benefits and performance characteristics. We will benchmark them in order to get a scientific basis fo...
Generalized Parsing: Part 3
November 23, 2020 06:00 - 36 minutes - 57 MB VideoSubscriber-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. --- Generalizing the parser type has allowed us to parse more types of inputs, but that is only scratching the surface. It also unlocks many new things that were previously impossible to see, including the ability to parse a stream of inputs and stream its output, making our parsers much more performant.
Generalized Parsing: Part 2
November 16, 2020 06:00 - 53 minutes - 18.3 MB VideoSubscriber-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 generalized the parser type it's time to parse things that aren't just plain strings. In just a few lines of code the parser type can parse environment variable dictionaries and even become a fully capable URL router.
Generalized Parsing: Part 1
November 09, 2020 06:00 - 33 minutes - 36.2 MB VideoSubscriber-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 parser type we built so far is highly tuned to work on strings, but there are many things out in the world we’d want to parse, not just strings. It’s time to massively generalize parsing so that it can parse any kind of input into any kind of output.
Fluently Zipping Parsers
November 02, 2020 06:00 - 51 minutes - 59.3 MB VideoSubscriber-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 zip function shows up on many types: from Swift arrays and Combine publishers, to optionals, results, and even parsers! But zip on parsers is a little unlike zip on all of those other types. Let's explore why and how to fix it.
Parsing Xcode Logs: Part 2
October 26, 2020 05:00 - 28 minutes - 17.3 MB VideoSubscriber-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 up our XCTest log parser by parsing out the data associated with a test failure. Once done we will format the results in a pretty way and package everything up in a CLI tool we can run in our own projects.
Parsing Xcode Logs: Part 1
October 19, 2020 05:00 - 31 minutes - 43.5 MB VideoSubscriber-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 refamiliarized ourselves with parsing, let's parse something even more complex: XCTest logs. We will parse and pretty-print the output from `xcodebuild` and discover more reusable combinators along the way.
Parser Combinators Recap: Part 2
October 12, 2020 05:00 - 38 minutes - 29.7 MB VideoSubscriber-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 parsing recap by reintroducing that functional trio of operators: map, zip, and flat-map. We'll use them to build up some complex parsers and make a few more ergonomic improvements to our library along the way.
Parser Combinators Recap: Part 1
October 05, 2020 05:00 - 25 minutes - 60.5 MB VideoSubscriber-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 revisit one of our favorite topics: parsing! We want to discuss lots of new parsing topics, such as generalized parsing, performance, reversible parsing and more, but before all of that we will start with a recap of what we have covered previously, and make a few improvements along the way.
The Point of Redacted SwiftUI: Part 2
September 21, 2020 05:00 - 26 minutes - 27.6 MB VideoSubscriber-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 building a rich onboarding experience for our application by selectively enabling and disabling pieces of logic in the app depending on what step of the onboarding process we are on. This is only possible due to the strict "separation of concerns" the Composable Architecture maintains.
The Point of Redacted SwiftUI: Part 1
September 14, 2020 05:00 - 29 minutes - 51.7 MB VideoSubscriber-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. --- Not only can we easily redact the logic from a view using the Composable Architecture, but we can also insert new logic into our views without making any changes to the core logic of the view. To demonstrate this we will build an onboarding flow for a more complex application.
Redacted SwiftUI: The Composable Architecture
September 07, 2020 05:00 - 20 minutes - 50.3 MB VideoSubscriber-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 seen how cool redacted SwiftUI views are, but we've also seen some of their pitfalls: while it's easy to redact UI, it's not so easy to redact logic, that is unless you're using the Composable Architecture!
🆓 █████ed SwiftUI: The Problem
August 31, 2020 05:00 - 25 minutes - 313 MB VideoEvery 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. --- SwiftUI has introduced the concept of “████ed views”, which gives you a really nice way to ████ the text and images from views. This is really powerful, but just because the view has been ████ed it doesn't mean the logic has also been ████ed. We show why this is prob...
Designing Dependencies: The Point
August 24, 2020 05:00 - 50 minutes - 62.2 MB VideoSubscriber-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's the point of forgoing the protocols and designing dependencies with simple data types? It can be summed up in 3 words: testing, testing, testing. We can now easily write tests that exercise every aspect of our application, including its reliance on internet connectivity and location services.
Designing Dependencies: Core Location
August 17, 2020 05:00 - 50 minutes - 38.1 MB VideoSubscriber-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 tackled two dependencies of varying complexity we are ready to handle our most complicated dependency yet: Core Location. We will see what it means to control a dependency that communicates with a delegate and captures a complex state machine with many potential flows.
Designing Dependencies: Reachability
August 10, 2020 05:00 - 46 minutes - 72.4 MB VideoSubscriber-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 straightforward to design the dependency for interacting with an API client, but sadly most dependencies we work with are not so simple. So let's consider a far more complicated dependency. One that is long living, and involves extra types that we can't even construct ourselves.
Designing Dependencies: Modularization
August 03, 2020 05:00 - 34 minutes - 5.48 MB VideoSubscriber-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 scrap the protocols for designing our dependencies and just use plain data types. Not only will we gain lots of new benefits that were previously impossible with protocols, but we'll also be able to modularize our application to improve compile times.
Designing Dependencies: The Problem
July 27, 2020 05:00 - 34 minutes - 141 MB VideoSubscriber-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 take a moment to properly define what a dependency is and understand why they add so much complexity to our code. We will begin building a moderately complex application with three dependencies, and see how it complicates development, and what we can do about it.
Composable SwiftUI Bindings: The Point
July 20, 2020 05:00 - 39 minutes - 43.6 MB VideoSubscriber-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 ask: "what's the point?" If composing bindings is so important, then why didn't Apple give us more tools to do it? To understand this we will explore how Apple handles these kinds of problems in their code samples, and compare it to what we have discovered in previous episodes.
Composable SwiftUI Bindings: Case Paths
July 13, 2020 05:00 - 45 minutes - 53.5 MB VideoSubscriber-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 know that SwiftUI state management seems biased towards structs, let's fix it. We'll show how to write custom transformations on bindings so that we can use enums to model our domains precisely without muddying our views, and it turns out that case paths are the perfect tool for this job.
Composable SwiftUI Bindings: The Problem
July 06, 2020 05:00 - 31 minutes - 55.1 MB VideoSubscriber-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. --- Bindings are one of the core units of SwiftUI data flow and allow disparate parts of an application to communicate with one another, but they are built in such a way that strongly favors structs over enums. We will show that this prevents us from properly modeling our domains and causes unnecessary co...
Combine Schedulers: Erasing Time
June 15, 2020 05:00 - 37 minutes - 30 MB VideoSubscriber-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 refactor our application's code so that we can run it in production with a live dispatch queue for the scheduler, while allowing us to run it in tests with a test scheduler. If we do this naively we will find that generics infect many parts of our code, but luckily we can employ the technique of ty...
Combine Schedulers: Controlling Time
June 08, 2020 05:00 - 1 hour - 19.5 MB VideoSubscriber-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 `Scheduler` protocol of Combine is a powerful abstraction that unifies many ways of executing asynchronous work, and it can even control the flow of time through our code. Unfortunately Combine doesn't give us this ability out of the box, so let's build it from scratch.
Combine Schedulers: Testing Time
June 04, 2020 05:00 - 49 minutes - 57.5 MB VideoSubscriber-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. --- Combine is a powerful framework and is the de facto way to power SwiftUI applications, but how does one test reactive code? We will build a view model from scratch that involves asynchrony and time-based effects and explore what it takes to exhaustively test its functionality.
🆓 A Tour of the Composable Architecture: Part 4
May 25, 2020 05:00 - 32 minutes - 321 MB VideoEvery 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 the Composable Architecture by demonstrating how to test a complex effect. This gives us a chance to show off how the library can control time-based effects by using Combine schedulers.
🆓 A Tour of the Composable Architecture: Part 3
May 18, 2020 05:00 - 32 minutes - 356 MB VideoEvery 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 start proving that our business logic works the way we expect. We are going to show how easy it is to write tests with the Composable Architecture, which will give us the confidence to add more functionality and explore some advanced effect capabilities ...
🆓 A Tour of the Composable Architecture: Part 2
May 11, 2020 05:00 - 28 minutes - 267 MB VideoEvery 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. --- Continuing the tour of our recently open-sourced library, the Composable Architecture, we start to employ some of the more advanced tools that come with the library. Right now our business logic and view is riddled with needless array index juggling, and a special hi...
🆓 A Tour of the Composable Architecture: Part 1
May 04, 2020 05:00 - 32 minutes - 384 MB VideoEvery 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 our 100th episode 🎉! To celebrate, we are finally releasing the Composable Architecture as an open source library, which means you can start using it in your applications today! Let's take a tour of the library, see how it's changed from what we built in earlier...
Ergonomic State Management: Part 2
April 20, 2020 05:00 - 24 minutes - 19.4 MB VideoSubscriber-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 made creating and enhancing reducers more ergonomic, but we still haven't given much attention to the ergonomics of the view layer of the Composable Architecture. This week we'll make the Store much nicer to use by taking advantage of a new Swift feature and by enhancing it with a SwiftUI helper.
Ergonomic State Management: Part 1
April 13, 2020 05:00 - 27 minutes - 41.5 MB VideoSubscriber-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 is robust and solves all of the problems we set out to solve (and more), but we haven't given enough attention to ergonomics. We will enhance one of its core units to be a little friendlier to use and extend, which will bring us one step closing to being ready for production.
Adaptive State Management: The Point
April 06, 2020 05:00 - 27 minutes - 59.2 MB VideoSubscriber-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 now shown that the Composable Architecture is also quite adaptive, allowing us to transform state and actions into very domain specific situations. Let's exercise those muscles by creating a macOS app from our iOS app and demonstrating that it's the perfect tool for creating cross-platform appli...
Adaptive State Management: Actions
March 30, 2020 05:00 - 42 minutes - 33.1 MB VideoSubscriber-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 we fixed a performance problem in the Composable Architecture it gave us an opportunity to adapt the state of our application to many situations. We'll take these learnings to see how our application's actions may adapt as well.
Adaptive State Management: State
March 23, 2020 05:00 - 40 minutes - 40.2 MB VideoSubscriber-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's a potential performance problem lurking in the Composable Architecture, and it's time to finally solve it. But, in doing so, we will stumble upon a wonderful way to make the architecture adaptive to many more situations.
Adaptive State Management: Performance
March 16, 2020 05:00 - 21 minutes - 65.5 MB VideoSubscriber-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 put the finishing touches to our architecture so that we can use it in production. This week we begin exploring how to make the Composable Architecture adapt to many use cases, and we will use a potential performance problem as inspiration for this exploration.
Modular Dependency Injection: The Point
March 02, 2020 06:00 - 44 minutes - 855 KB VideoSubscriber-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 prove that baking an "environment" of dependencies directly into the Composable Architecture solves three crucial problems that the global environment pattern could not.
Dependency Injection Made Modular
February 24, 2020 06:00 - 34 minutes - 19.8 MB VideoSubscriber-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 baked the "environment" of dependencies directly into the Composable Architecture, we're ready to refactor our app's frameworks and tests to work with them in a modular and more lightweight way.
Dependency Injection Made Composable
February 17, 2020 06:00 - 32 minutes - 55 MB VideoSubscriber-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 love the "environment" approach to dependency injection, which we introduced many episodes ago, it doesn't feel quite right in the Composable Architecture and introduces a few problems in how we manage dependencies. Today we'll make a small tweak to the architecture in order to solve them!
Composing Architecture with Case Paths
February 10, 2020 06:00 - 22 minutes - 56.1 MB VideoSubscriber-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 a real world application of "case paths," which provide key path-like functionality to enum cases. We'll upgrade our composable architecture to use them and see why they're a better fit than our existing approach.
Case Paths for Free
February 03, 2020 06:00 - 35 minutes - 44.4 MB VideoSubscriber-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. --- Although case paths are powerful and a natural extension of key paths, they are difficult to work with right now. They require either hand-written boilerplate, or code generation. However, there's another way to generate case paths for free, and it will make them just as ergonomic to use as key paths.
The Case for Case Paths: Properties
January 27, 2020 06:00 - 24 minutes - 17.5 MB VideoSubscriber-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 now seen that it's possible to define "case paths": the enum equivalent of key paths. So what are their features? Let's explore a few properties of key paths to see if there are corresponding concepts on case paths.