Podcasts by Point-Free Videos
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.
Further podcasts by Brandon Williams & Stephen Celis
Podcast on the topic Technologie
All episodes
Observable Architecture: Observing Optionals from 2023-12-11T00:00
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 ...
Listen
Observable Architecture: Structural Identity from 2023-12-04T00:00
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. ---One ...
Listen
🆓Observable Architecture: Sneak Peek from 2023-11-27T00:00
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:/...
Listen
Macro Case Paths: Part 2 from 2023-11-20T00:00
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 h...
Listen
Macro Case Paths: Part 1 from 2023-11-13T00:00
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. ---“Cas...
Listen
Observation in Practice from 2023-11-06T00:00
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 t...
Listen
🆓Tour of Parser-Printers: Vapor Routing from 2022-05-02T05:00
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:/...
Listen
🆓Tour of Parser-Printers: URL Routing from 2022-04-25T05:00
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:/...
Listen
🆓Tour of Parser-Printers: vs. Swift's Regex DSL from 2022-04-18T05:00
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:/...
Listen
🆓Tour of Parser-Printers: Introduction from 2022-04-11T05:00
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:/...
Listen
Invertible Parsing: The Point from 2022-04-04T05:00
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 c...
Listen
Invertible Parsing: Bizarro Printing from 2022-03-28T05:00
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'v...
Listen
Invertible Parsing: Map from 2022-03-21T05:00
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 ...
Listen
Invertible Parsing: Generalization from 2022-03-14T05:00
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 ...
Listen
Invertible Parsing: The Solution, Part 2 from 2022-03-07T06:00
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 w...
Listen
Invertible Parsing: The Solution, Part 1 from 2022-02-28T06:00
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 ...
Listen
Invertible Parsing: The Problem from 2022-02-21T06:00
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'v...
Listen
Parser Errors: Context and Ergonomics from 2022-02-07T06:00
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'...
Listen
Parser Errors: from Nil to Throws from 2022-01-31T06:00
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'...
Listen
Parser Builders: The Point from 2022-01-24T06:00
? 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 on...
Listen
Parser Builders: The Solution from 2022-01-17T06:00
? 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.
Listen
Parser Builders: The Problem from 2022-01-10T06:00
? Let’s revisit a favorite topic: parsing! After a short recap, we will theorize and motivate the addition of result builder syntax to our parsing library, which will help unlock a new level of erg...
Listen
Modularization: Part 2 from 2021-12-20T06:00
? We finish modularizing our application by extracting its deep linking logic across feature modules. We will then show the full power of modularization by building a "preview" application that can...
Listen
? Modularization: Part 1 from 2021-12-13T06:00
? We've talked about modularity a lot in the past, but we've never devoted full episodes to show how we approach the subject. We will define and explore various kinds of modularity, and we’ll show ...
Listen
UIKit Navigation: Part 2 from 2021-12-06T06:00
? We finish porting our SwiftUI application to UIKit by introducing a collection view. Along the way we will demonstrate how deep-linking works exactly as it did in SwiftUI, and we show the power o...
Listen
UIKit Navigation: Part 1 from 2021-11-29T06:00
? What does all the work we've done with navigation in SwiftUI have to say about UIKit? Turns out a lot! Without making a single change to the view models we can rewrite the entire view layer in UI...
Listen
SwiftUI Navigation: The Point from 2021-11-15T06:00
? We've claimed that the way we handle navigation in SwiftUI unlocks the ability to deep link to any screen in your application, so let's put that claim to the test. We will add real-world deep lin...
Listen
SwiftUI Navigation: Links, Part 3 from 2021-11-08T06:00
? Over the past weeks we have come up with some seriously powerful tools for SwiftUI navigation that have allowed us to more precisely and correctly model our app's domain, so let's exercise them a...
Listen
SwiftUI Navigation: Links, Part 2 from 2021-11-01T05:00
? Let's explore "tag" and "selection"-based navigation links in SwiftUI. What are they for and how do they compare with the link and link helpers we've used so far? We will then take a step back to...
Listen
SwiftUI Navigation: Links, Part 1 from 2021-10-25T05:00
? It's time to explore the most complex form of navigation in SwiftUI: links! We'll start with some simpler flavors of `NavigationLink` to see how they work, how they compare with other navigation ...
Listen
SwiftUI Navigation: Sheets & Popovers, Part 3 from 2021-10-18T05:00
? Now that we've built up the tools needed to bind application state to navigation, let's exercise them. We'll quickly add *two* more features to our application, beef up our navigation tools, and ...
Listen
SwiftUI Navigation: Sheets & Popovers, Part 2 from 2021-10-11T05:00
? This week we’ll explore how to drive a sheet with optional state and how to facilitate communication between the sheet and the view presenting it. In the process we will discover a wonderful bind...
Listen
SwiftUI Navigation: Sheets & Popovers, Part 1 from 2021-10-04T05:00
? It's time to look at a more advanced kind of navigation: modals. We will implement a new feature that will be driven by a sheet and can be deep-linked into. Along the way we'll introduce a helper...
Listen
SwiftUI Navigation: Tabs & Alerts, Part 2 from 2021-09-27T05:00
? We continue our journey exploring navigation with an examination of alerts and action sheets. We'll compare their original APIs in SwiftUI to the ones that replace them in the SDK that just shipp...
Listen
SwiftUI Navigation: Tabs & Alerts, Part 1 from 2021-09-20T05:00
? Navigation is a really, really complex topic, and it's going to take us many episodes go deep into it. We will begin our journey by coming up with a precise definition of what "navigation" is, an...
Listen
Safer, Conciser Forms: Part 2 from 2021-09-06T05:00
? We just made the Composable Architecture's concise binding helpers safer, but can we make them even more concise? We'll start with a suggestion that came from the community and employ even more S...
Listen
Safer, Conciser Forms: Part 1 from 2021-08-30T05:00
? Previously we explored how SwiftUI makes building forms a snap, and we contrasted it with the boilerplate introduced by the Composable Architecture. We employed a number of advanced tools to clos...
Listen
Searchable SwiftUI: Part 2 from 2021-08-16T05:00
? We finish our search-based application by adding and controlling another MapKit API, integrating it into our application so we can annotate a map with search results, and then we'll go the extra ...
Listen
Searchable SwiftUI: Part 1 from 2021-08-09T05:00
? Let's develop a new application from scratch to explore SwiftUI's new `.searchable` API. We'll use MapKit to search for points of interest, and we will control this complex dependency so that our...
Listen
SwiftUI Focus State from 2021-08-02T05:00
? Let's explore another API just announced at WWDC: `@FocusState`. We'll take a simple example and layer on some complexity, including side effects and testability, and we'll see that the solution ...
Listen
Async Refreshable: Composable Architecture from 2021-07-26T05:00
? The Composable Architecture does not yet support any of the fancy new concurrency features from WWDC this year, so is it possible to interact with async/await APIs like `.refreshable`? Not only i...
Listen
Async Refreshable: SwiftUI from 2021-07-19T05:00
? Let's take a look at the new refreshable API in SwiftUI. We will explore how to add it to a feature, how it depends on Swift's new async/await tools, and how to introduce cancellation.
Listen
Composable Architecture Performance: Case Paths from 2021-07-05T05:00
? This week we improve the performance of another part of the Composable Architecture ecosystem: case paths! We will benchmark the reflection mechanism that powers case paths and speed things up wi...
Listen
Composable Architecture Performance: View Stores and Scoping from 2021-06-28T05:00
? Did you know the Composable Architecture's `scope` operation and `ViewStore` are performance tools? We'll explore how to diagnose your app's performance, how `scope` can help, and fix a few long-...
Listen
Derived Behavior: The Point from 2021-06-21T05:00
? We typically rewrite vanilla SwiftUI applications into Composable Architecture applications, but this week we do the opposite! We will explore "deriving behavior" by taking an existing TCA app an...
Listen
Derived Behavior: Optionals and Enums from 2021-06-14T05:00
? We will explore two more domain transformations in the Composable Architecture. One comes with the library: the ability to embed a smaller domain, optionally, in a larger domain. Another we will ...
Listen
Derived Behavior: Collections from 2021-05-31T05:00
? The Composable Architecture comes with several tools that aid in breaking large domains down into smaller ones, not just `pullback` and `scope`. This week we will see how it can take a small doma...
Listen
Derived Behavior: Composable Architecture from 2021-05-24T05:00
? Let's rebuild last week's moderately complex SwiftUI app in the Composable Architecture to explore its built-in solution for breaking larger domains down into smaller ones using the `scope` opera...
Listen
Derived Behavior: The Problem from 2021-05-17T05:00
? The ability to break down applications into small domains that are understandable in isolation is a universal problem, and yet there is no default story for doing so in SwiftUI. We explore the pr...
Listen
? A Tour of isowords: Part 4 from 2021-05-10T05:00
? We wrap up our tour of [isowords](https://www.isowords.xyz) by showing off two powerful ways the iOS client and Swift server share code. Not only does the same code that routes server requests si...
Listen
? A Tour of isowords: Part 3 from 2021-05-03T07:00
? It's time to take a look at the other half of the [isowords](https://www.isowords.xyz) code base: the server! We'll get you running the server locally, and then explore some benefits of developin...
Listen
? A Tour of isowords: Part 2 from 2021-04-26T07:00
? Let's dive deeper into the [isowords](https://www.isowords.xyz) code base. We'll explore how the Composable Architecture and modularization unlocked many things, including the ability to add an o...
Listen
? A Tour of isowords: Part 1 from 2021-04-19T07:00
? In past episodes we took a peek behind the curtains of our recently released iOS game, [isowords](https://www.isowords.xyz). Now it's time to dive deep into the code base to see how it's built. W...
Listen
Better Test Dependencies: The Point from 2021-04-05T05:00
? Crafting better test dependencies for our code bases come with additional benefits outside of testing. We show how SwiftUI previews can be strengthened from better dependencies, and we show how w...
Listen
Better Test Dependencies: Immediacy from 2021-03-29T05:00
? A major source of complexity in our applications is asynchrony. It is a side effect that is easy to overlook and can make testing more difficult and less reliable. We will explore the problem and...
Listen
Better Test Dependencies: Failability from 2021-03-22T05:00
? Exhaustively describing dependencies in your tests makes them stronger _and_ easier to understand. We improve the ergonomics of this technique by ditching the `fatalError` in unimplemented depend...
Listen
Better Test Dependencies: Exhaustivity from 2021-03-15T05:00
? We talk about dependencies a lot on Point-Free, but we've never done a deep dive on how to tune them for testing. It's time to do just that, by first showing how a test can exhaustively describe ...
Listen
SwiftUI Animation: The Point from 2021-03-01T06:00
? 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 ...
Listen
SwiftUI Animation: Composable Architecture from 2021-02-22T06:00
? 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...
Listen
SwiftUI Animation: The Basics from 2021-02-15T06:00
? 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 he...
Listen
? Concise Forms: The Point from 2021-02-08T07:00
? 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: [...
Listen
Concise Forms: Bye Bye Boilerplate from 2021-02-01T06:00
? 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 ke...
Listen
Concise Forms: Composable Architecture from 2021-01-25T06:00
? 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 natural...
Listen
Concise Forms: SwiftUI from 2021-01-18T06:00
? 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 bein...
Listen
? Parsing and Performance: The Point from 2020-12-21T07:00
? 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 ge...
Listen
Parsing and Performance: Protocols from 2020-12-14T06:00
? 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 ...
Listen
Parsing and Performance: Combinators from 2020-12-07T06:00
? 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 togethe...
Listen
Parsing and Performance: Strings from 2020-11-30T06:00
? 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...
Listen
Generalized Parsing: Part 3 from 2020-11-23T06:00
? 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, includi...
Listen
Generalized Parsing: Part 2 from 2020-11-16T06:00
? 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 ...
Listen
Generalized Parsing: Part 1 from 2020-11-09T06:00
? 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 t...
Listen
Fluently Zipping Parsers from 2020-11-02T06:00
? 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. ...
Listen
Parsing Xcode Logs: Part 2 from 2020-10-26T05:00
? 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 ...
Listen
Parsing Xcode Logs: Part 1 from 2020-10-19T05:00
? 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 ...
Listen
Parser Combinators Recap: Part 2 from 2020-10-12T05:00
? 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 improvemen...
Listen
Parser Combinators Recap: Part 1 from 2020-10-05T05:00
? 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 t...
Listen
The Point of Redacted SwiftUI: Part 2 from 2020-09-21T05:00
? 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. Th...
Listen
The Point of Redacted SwiftUI: Part 1 from 2020-09-14T05:00
? 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...
Listen
Redacted SwiftUI: The Composable Architecture from 2020-09-07T05:00
? 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 Composa...
Listen
? ?????ed SwiftUI: The Problem from 2020-08-31T07:00
? 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 ...
Listen
Designing Dependencies: The Point from 2020-08-24T05:00
? 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 exe...
Listen
Designing Dependencies: Core Location from 2020-08-17T05:00
? 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 com...
Listen
Designing Dependencies: Reachability from 2020-08-10T05:00
? 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. ...
Listen
Designing Dependencies: Modularization from 2020-08-03T05:00
? 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 b...
Listen
Designing Dependencies: The Problem from 2020-07-27T05:00
? 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 dependen...
Listen
Composable SwiftUI Bindings: The Point from 2020-07-20T05:00
? 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...
Listen
Composable SwiftUI Bindings: Case Paths from 2020-07-13T05:00
? 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...
Listen
Composable SwiftUI Bindings: The Problem from 2020-07-06T05:00
? 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 ...
Listen
Combine Schedulers: Erasing Time from 2020-06-15T05:00
? 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 naiv...
Listen
Combine Schedulers: Controlling Time from 2020-06-08T05:00
? 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 Combi...
Listen
Combine Schedulers: Testing Time from 2020-06-04T05:00
? 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 ti...
Listen
? A Tour of the Composable Architecture: Part 4 from 2020-05-25T07:00
? 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 Combi...
Listen
? A Tour of the Composable Architecture: Part 3 from 2020-05-18T07:00:01
? 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 ...
Listen
? A Tour of the Composable Architecture: Part 2 from 2020-05-11T07:00
? 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 ...
Listen
? A Tour of the Composable Architecture: Part 1 from 2020-05-04T07:00
? 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...
Listen
Ergonomic State Management: Part 2 from 2020-04-20T05:00
? 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 S...
Listen
Ergonomic State Management: Part 1 from 2020-04-13T05:00
? 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 ...
Listen
Adaptive State Management: The Point from 2020-04-06T05:00
? 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 ...
Listen
Adaptive State Management: Actions from 2020-03-30T05:00
? 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 ap...
Listen
Adaptive State Management: State from 2020-03-23T05:00
? 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 ...
Listen
Adaptive State Management: Performance from 2020-03-16T05:00
? 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 w...
Listen
Modular Dependency Injection: The Point from 2020-03-02T06:00
? 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.
Listen
Dependency Injection Made Modular from 2020-02-24T06:00
? 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 li...
Listen
Dependency Injection Made Composable from 2020-02-17T06:00
? 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 i...
Listen
Composing Architecture with Case Paths from 2020-02-10T06:00
? 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...
Listen
Case Paths for Free from 2020-02-03T06:00
? 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'...
Listen
The Case for Case Paths: Properties from 2020-01-27T06:00
? 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 correspondi...
Listen
The Case for Case Paths: Introduction from 2020-01-20T06:00
? You've heard of key paths, but…case paths!? Today we introduce the concept of "case paths," a tool that helps you generically pick apart an enum just like key paths allow you to do for structs. I...
Listen
? SwiftUI Snapshot Testing from 2019-12-23T07:00
? In this week's free holiday episode we show what it looks like to snapshot test a SwiftUI application in our architecture and compare this style of integration testing against XCTest's UI testing...
Listen
? Testable State Management: The Point from 2019-12-16T07:00
? We've made testing in our architecture a joy! We can test deep aspects of our application with minimal ceremony, but it took us a whole 18 episodes to get here! So this week we ask: what's the po...
Listen
Testable State Management: Ergonomics from 2019-12-09T06:00
? We not only want our architecture to be testable, but we want it to be super easy to write tests, and perhaps even a joy to write tests! Right now there is a bit of ceremony involved in writing t...
Listen
Testable State Management: Effects from 2019-12-02T06:00
? Side effects are by far the hardest thing to test in an application. They speak to the outside world and they tend to be sprinkled around to get the job done. However, we can get broad test cover...
Listen
Testable State Management: Reducers from 2019-11-25T06:00
? It's time to see how our architecture handles the fifth and final problem we identified as being important to solve when building a moderately complex application: testing! Let's get our feet wet...
Listen
? The Combine Framework and Effects: Part 2 from 2019-11-18T07:00
? Now that we've explored the Combine framework and identified its correspondence with the `Effect` type, let's refactor our architecture to take full advantage of it.
Listen
? The Combine Framework and Effects: Part 1 from 2019-11-11T07:00
? Let's explore the Combine framework and its correspondence with the Effect type. Combine introduces several concepts that overlap with how we model effects in our composable architecture. Let's g...
Listen
Effectful State Management: The Point from 2019-11-04T06:00
? We've got the basic story of side effects in our architecture, but the story is far from over. Turns out that even side effects themselves are composable. Base effect functionality can be extract...
Listen
Effectful State Management: Asynchronous Effects from 2019-10-28T06:00
? It's time to finish our architecture's story for side effects. We've described synchronous effects and unidirectional effects, but we still haven't captured the complexity of async effects. Let's...
Listen
Effectful State Management: Unidirectional Effects from 2019-10-21T06:00
? We've modeled side effects in our architecture, but it's not quite right yet: a reducer can write to the outside world, but it can't read data back in! This week our architecture's dedication to ...
Listen
Effectful State Management: Synchronous Effects from 2019-10-14T06:00
? Side effects are one of the biggest sources of complexity in any application. It's time to figure out how to model effects in our architecture. We begin by adding a few new side effects, and then...
Listen
Modular State Management: The Point from 2019-10-07T06:00
? We’ve now fully modularized our app by extracting its reducers and views into their own modules. Each screen of our app can be run as a little app on its own so that we can test its functionality...
Listen
Modular State Management: View Actions from 2019-09-30T06:00
? It's time to fully modularize our app! Our views can still send any app action, so let's explore transforming stores to focus in on just the local actions a view cares about.
Listen
Modular State Management: View State from 2019-09-23T06:00
? While we've seen that each reducer we've written is super modular, and we were easily able to extract each one into a separate framework, our views are still far from modular. This week we addres...
Listen
Modular State Management: Reducers from 2019-09-09T06:00
? In exploring four forms of composition on reducer functions, we made the claim that it gave us the power to fully isolate app logic, making it simpler and easier to understand. This week we put o...
Listen
Composable State Management: Higher-Order Reducers from 2019-08-26T06:00
? We will explore a form of reducer composition that will take our applications to the _next level_. Higher-order reducers will allow us to implement broad, cross-cutting functionality on top of ou...
Listen
Composable State Management: Action Pullbacks from 2019-08-19T06:00
? Turns out, reducers that work on local actions can be _pulled back_ to work on global actions. However, due to an imbalance in how Swift treats enums versus structs it takes a little work to impl...
Listen
Composable State Management: State Pullbacks from 2019-08-12T06:00
? So far we have pulled a lot of our application's logic into a reducer, but that reducer is starting to get big. Turns out that reducers emit many types of powerful compositions, and this week we ...
Listen
Composable State Management: Reducers from 2019-08-05T06:00
? Now that we understand some of the fundamental problems that we will encounter when building a complex application, let's start solving some of them! We will begin by demonstrating a technique fo...
Listen
? SwiftUI and State Management: Part 3 from 2019-07-29T08:00
? With our moderately complex SwiftUI application complete we can finally ask ourselves: "what's the point!?" What does SwiftUI have to say about app architecture? What questions are left unanswere...
Listen
? SwiftUI and State Management: Part 2 from 2019-07-22T08:00
? This week we finish up our moderately complex SwiftUI application by adding more screens, more state, and even sprinkle in a side effect so that we can finally ask: "what's the point!?"
Listen
? SwiftUI and State Management: Part 1 from 2019-07-15T08:00
? Let's begin exploring application architecture by understanding what are the common problems we encounter when trying to build large, complex applications. We will build an app in SwiftUI to see ...
Listen
Parser Combinators: Part 3 from 2019-07-08T06:00
? Now that we've looked at how to parse multiple values given a single parser, let's try to parse a single value using multiple parsers! And after defining a bunch of these parser combinators we'll...
Listen
Parser Combinators: Part 2 from 2019-07-01T06:00
? Let's solve another common parsing problem using parser combinators! It's common to want to parse multiple values off a string, and while `zip` gets us part of the way there, it doesn't let us pa...
Listen
Parser Combinators: Part 1 from 2019-06-24T06:00
? Even though `map`, `flatMap` and `zip` pack a punch, there are still many parsing operations that can't be done using them alone. This is where "parser combinators" come into play. Let's look at ...
Listen
Composable Parsing: Zip from 2019-06-10T06:00
? While `flatMap` allowed us to take our parser type to the next level, it introduced a nesting problem. Isn't `flatMap` all about solving nesting problems!? Well, we have one more operation at our...
Listen
Composable Parsing: Flat?Map from 2019-06-03T08:00
? The `map` function on parsers is powerful, but there are still a lot of things it cannot do. We will see that in trying to solve some of its limitations we are naturally led to our old friend the...
Listen
Composable Parsing: Map from 2019-05-27T06:00
? We now have a precise, efficient definition for parsing, but we haven't even scratched the surface of its relation to functional programming. In this episode we begin to show how all of the funct...
Listen
What Is a Parser?: Part 3 from 2019-05-20T06:00
? It's time to ask the all important question: what's the point? We now have a properly defined parser type, one that can parse efficiently and incrementally, but does it give us anything new over ...
Listen
What Is a Parser?: Part 2 from 2019-05-13T06:00
? Now that we've looked at a bunch of parsers that are at our disposal, let's ask ourselves what a parser really is from the perspective of functional programming and functions. We'll take a multi-...
Listen
What Is a Parser?: Part 1 from 2019-05-06T06:00
? Parsing is a difficult, but surprisingly ubiquitous programming problem, and functional programming has a lot to say about it. Let's take a moment to understand the problem space of parsing, and ...
Listen
? Swift Syntax Command Line Tool from 2019-04-22T08:00
? Today we finally extract our enum property code generator to a Swift Package Manager library and CLI tool. We'll also do some next-level snapshot testing: not only will we snapshot-test our gener...
Listen
Advanced Swift Syntax Enum Properties from 2019-04-15T06:00
? This week we'll put the finishing touches on our enum property code generation tool. We'll add support for enum cases with multiple associated values and enum cases with no associated values, and...
Listen
Swift Syntax Enum Properties from 2019-04-08T06:00
? We've seen how "enum properties" help close the gap between the ergonomics of accessing data on structs and enums, but defining them by hand requires a _lot_ of boilerplate. This week we join for...
Listen
Enum Properties from 2019-04-01T06:00
? Swift makes it easy for us to access the data inside a struct via dot-syntax and key-paths, but enums are provided no such affordances. This week we correct that deficiency by defining the concep...
Listen
Structs ? Enums from 2019-03-25T07:00
? Name a more iconic duo... We'll wait. Structs and enums go together like peanut butter and jelly, or multiplication and addition. One's no more important than the other: they're completely comple...
Listen
? Generative Art: Part 2 from 2019-03-11T07:00
? Let's put some finishing touches to our random artwork generator, incorporate it into an app, and write some snapshot tests to help support us in adding a fun easter egg.
Listen
? Generative Art: Part 1 from 2019-03-04T08:00
? Now that we have made randomness both composable _and_ testable, let's have a little fun with it! We are going to explore making some complex generative art that is built from simple, composable ...
Listen
Predictable Randomness: Part 2 from 2019-02-25T07:00
? This week we finally make our untestable Gen type testable. We'll compare several different ways of controlling Gen, consider how they affect Gen's API, and find ourselves face-to-face with yet a...
Listen
Predictable Randomness: Part 1 from 2019-02-18T07:00
? Let's set out to make the untestable testable. This week we make composable randomness compatible with Swift's new APIs and explore various ways of controlling those APIs, both locally and globally.
Listen
The Many Faces of Flat?Map: Part 5 from 2019-02-04T08:00
? Finishing our 3-part answer to the all-important question "what's the point?", we finally show that standing on the foundation of our understanding of `map`, `zip` and `flatMap` we can now ask an...
Listen
The Many Faces of Flat?Map: Part 4 from 2019-01-28T08:00
? Continuing our 3-part answer to the all-important question "what's the point?", we show that the definitions of `map`, `zip` and `flatMap` are precise and concisely describe their purpose. Knowin...
Listen
The Many Faces of Flat?Map: Part 3 from 2019-01-21T08:00
? We are now ready to answer the all-important question: what's the point? We will describe 3 important ideas that are now more accessible due to our deep study of `map`, `zip` and `flatMap`. We wi...
Listen
The Many Faces of Flat?Map: Part 2 from 2019-01-16T08:00
? Now that we know that `flatMap` is important for flattening nested arrays and optionals, we should feel empowered to define it on our own types. This leads us to understanding its structure more ...
Listen
The Many Faces of Flat?Map: Part 1 from 2019-01-07T08:00
? Previously we've discussed the `map` and `zip` operations in detail, and today we start completing the trilogy by exploring `flatMap`. This operation is precisely the tool needed to solve a nesti...
Listen
? A Tour of Snapshot Testing from 2018-12-18T08:00
? Our snapshot testing library is now officially open source! In order to show just how easy it is to integrate the library into any existing code base, we add some snapshot tests to a popular open...
Listen
Async Functional Refactoring from 2018-12-17T07:00
? The snapshot testing library we have been designing over the past few weeks has a serious problem: it can't snapshot asynchronous values, like web views and anything that uses delegates or callba...
Listen
Witness-Oriented Library Design from 2018-11-26T05:00
? We previously refactored a library using protocols to make it more flexible and extensible but found that it wasn't quite as flexible or extensible as we wanted it to be. This week we re-refactor...
Listen
Protocol-Oriented Library Design: Part 2 from 2018-11-19T06:00
? With our library fully generalized using protocols, we show off the flexibility of our abstraction by adding new conformances and functionality. In fleshing out our library we find out why protoc...
Listen
Protocol-Oriented Library Design: Part 1 from 2018-11-12T09:00
? Perhaps the most popular approach to code reuse and extensibility in Swift is to liberally adopt protocol-oriented programming, and many Swift libraries are designed with protocol-heavy APIs. In ...
Listen
Advanced Protocol Witnesses: Part 2 from 2018-11-05T09:00
? We complete our dictionary for translating Swift protocol concepts into concrete datatypes and functions. This includes protocol inheritance, protocol extensions, default implementations _and_ pr...
Listen
Advanced Protocol Witnesses: Part 1 from 2018-10-29T09:00
? Now that we know it's possible to replace protocols with concrete datatypes, and now that we've seen how that opens up new ways to compose things that were previously hidden from us, let's go a l...
Listen
Protocol Witnesses: Part 2 from 2018-10-22T05:48:42
? Last time we covered some basics with protocols, and demonstrated one of their biggest pitfalls: types can only conform to a protocol a single time. Sometimes it's valid and correct for a type to...
Listen
Protocol Witnesses: Part 1 from 2018-10-15T05:48:42
? Protocols are a great tool for abstraction, but aren't the only one. This week we begin to explore the tradeoffs of using protocols by highlighting a few areas in which they fall short in order t...
Listen
Decodable Randomness: Part 2 from 2018-10-01T05:57:03
? This week we compare our `Decodable` solution to building random structures with a composable solution involving the `Gen` type, exploring the differences and trade-offs of each approach. Along t...
Listen
Decodable Randomness: Part 1 from 2018-09-24T05:57:03
? This week we dive deeper into randomness and composition by looking to a seemingly random place: the `Decodable` protocol. While we're used to using the `Codable` set of protocols when working wi...
Listen
Composable Randomness from 2018-09-17T05:57:03
? Randomness is a topic that may not seem so functional, but it gives us a wonderful opportunity to explore composition. After a survey of what randomness looks like in Swift today, we'll build a c...
Listen
? DSLs vs. Templating Languages from 2018-09-10T07:57:03
? Templating languages are the most common way to render HTML in web frameworks, but we don't think they are the best way. We compare templating languages to the DSL we previously built, and show t...
Listen
An HTML DSL from 2018-09-03T05:57:03
? This week we apply domain-specific languages to a very real-world problem: representing and rendering HTML. We code up a simple but powerful solution that forms the foundation of what we use to b...
Listen
Domain?Specific Languages: Part 2 from 2018-08-27T07:57:03
? We finish our introduction to DSLs by adding two new features to our toy example: support for multiple variables and support for let-bindings so that we can share subexpressions within a larger e...
Listen
Domain?Specific Languages: Part 1 from 2018-08-20T07:57:03
? We interact with domain-specific languages on a daily basis, but what does it take to build your own? After introducing the topic, we will begin building a toy example directly in Swift, which wi...
Listen
? The Many Faces of Zip: Part 3 from 2018-08-06T07:57:03
? The third, and final, part of our introductory series to `zip` finally answers the question: "What's the point?"
Listen
The Many Faces of Zip: Part 2 from 2018-07-30T05:57:03
? In part two of our series on `zip` we will show that many types support a `zip`-like operation, and some even support multiple distinct implementations. However, not all `zip`s are created equal,...
Listen
The Many Faces of Zip: Part 1 from 2018-07-23T09:57:03
? The `zip` function comes with the Swift standard library, but its utility goes far beyond what we can see there. Turns out, `zip` generalizes a function that we are all familiar with, and it can ...
Listen
? A Tour of Point-Free from 2018-07-16T11:57:03
? Join us for a tour of the code base that powers this very site and see what functional programming can look like in a production code base! We'll walk through cloning the repo and getting the sit...
Listen
Playground Driven Development from 2018-07-09T09:57:03
? We use Swift playgrounds on this series as a tool to dive deep into functional programming concepts, but they can be so much more. Today we demonstrate a few tricks to allow you to use playground...
Listen
Contravariance from 2018-06-12T09:57:03
? Let's explore a type of composition that defies our intuitions. It appears to go in the opposite direction than we are used to. We'll show that this composition is completely natural, hiding righ...
Listen
Algebraic Data Types: Generics and Recursion from 2018-06-11T09:57:03
? Our third installment of algebraic data types explores how generics and recursive data types manifest themselves in algebra. This exploration allows us to construct a useful, precise type that ca...
Listen
Dependency Injection Made Comfortable from 2018-06-04T09:57:03
? Let's have some fun with the "environment" form of dependency injection we previously explored. We're going to extract out a few more dependencies, strengthen our mocks, and use our Overture libr...
Listen
Styling with Overture from 2018-05-28T09:57:03
? We revisit an old topic: styling UIKit components. Using some of the machinery we have built from previous episodes, in particular setters and function composition, we refactor a screen's styles ...
Listen
Dependency Injection Made Easy from 2018-05-21T09:57:03
? Today we're going to control the world! Well, dependencies to the outside world, at least. We'll define the "dependency injection" problem and show a lightweight solution that can be implemented ...
Listen
Setters: Ergonomics & Performance from 2018-05-14T09:57:03
? Functional setters can be very powerful, but the way we have defined them so far is not super ergonomic or performant. We will provide a friendlier API to use setters and take advantage of Swift'...
Listen
The Many Faces of Map from 2018-04-23T09:57:03
? Why does the `map` function appear in every programming language supporting "functional" concepts? And why does Swift have _two_ `map` functions? We will answer these questions and show that `map...
Listen
Composition without Operators from 2018-04-09T09:57:03
? While we unabashedly promote custom operators in this series, we understand that not every codebase can adopt them. Composition is too important to miss out on due to operators, so we want to exp...
Listen
? A Tale of Two Flat?Maps from 2018-03-27T11:57:03
? Swift 4.1 deprecated and renamed a particular overload of `flatMap`. What made this `flatMap` different from the others? We'll explore this and how understanding that difference helps us explore ...
Listen
Algebraic Data Types: Exponents from 2018-03-26T09:57:03
? We continue our explorations into algebra and the Swift type system. We show that exponents correspond to functions in Swift, and that by using the properties of exponents we can better understan...
Listen
Getters and Key Paths from 2018-03-19T09:57:03
? Key paths aren’t just for setting. They also assist in getting values inside nested structures in a composable way. This can be powerful, allowing us to make the Swift standard library more expre...
Listen
Setters and Key Paths from 2018-03-12T09:57:03
? This week we explore how functional setters can be used with the types we build and use everyday. It turns out that Swift generates a whole set of functional setters for you to use, but it can be...
Listen
Functional Setters from 2018-03-05T10:57:03
? The programs we write can be reduced to transforming data from one form into another. We’re used to transforming this data imperatively, with setters. There’s a strange world of composition hidin...
Listen
Higher-Order Functions from 2018-02-26T13:57:03
? Most of the time we interact with code we did not write, and it doesn’t always play nicely with the types of compositions we have developed in previous episodes. We explore how higher-order funct...
Listen
? Algebraic Data Types from 2018-02-19T14:12:31
? What does the Swift type system have to do with algebra? A lot! We’ll begin to explore this correspondence and see how it can help us create type-safe data structures that can catch runtime error...
Listen
? UIKit Styling with Functions from 2018-02-12T14:12:31
? We bring tools from previous episodes down to earth and apply them to an everyday task: UIKit styling. Plain functions unlock worlds of composability and reusability in styling of UI components. ...
Listen
? Side Effects from 2018-02-05T07:11:09
? Side effects: can’t live with ’em; can’t write a program without ’em. Let’s explore a few kinds of side effects we encounter every day, why they make code difficult to reason about and test, and ...
Listen
? We launched! from 2018-01-29T07:11:09
? Point-Free is here, bringing you videos covering functional programming concepts using the Swift language. Take a moment to hear from the hosts about what to expect from this new series.
Listen
? Functions from 2018-01-29T07:11:09
? Our first episode is all about functions! We talk a bit about what makes functions special, contrasting them with the way we usually write code, and have some exploratory discussions about operat...
Listen