Point-Free Videos

🔒 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.

🔒 We will employ `@Shared`'s new testing capabilities in a complex scenario: a sign up flow. We

will see how a deeply nested integration of features all sharing the same state can be tested

simply, and we will see how we can leverage the same tricks employed by the test store to add

debug tools to reducers using shared state.

🔒 The `@Shared` property wrapper can effortlessly share state among features to build complex

flows quickly, but because it is powered by a reference type, it is not compatible with the

Composable Architecture's value-oriented testing tools. Let's address these shortcomings and

recover all of the library's testing niceties.

🔒 We finish building a complex, flow-based case study that leverages the new `@Shared` property

wrapper. Along the way we will flex recently added superpowers of the library, and we will

experience firsthand how simple this new model of shared state can be.

🔒 The various approaches of sharing state in the Composable Architecture are mixed bag of trade

offs and problems. Is there a better way? We’ll take a controversial approach: we will

introduce a reference type into our state, typically a value type, and see what happens, and

take it for a spin in an all new, flow-based case study.

🔒 We tackle one of the biggest problems when it comes to "single source of truth" applications,

and that is: how do you share state? Let's begin by analyzing the problem, and truly

understanding what vague mantras like "single source of truth" even mean, and then we will

be in a good position to provide a wonderful solution.

🔒 To celebrate our 6th anniversary we had another livestream! We updated an app from the most

recent Composable Architecture tour to the latest observation tools, showed how these tools

can improve UIKit-based apps, showed off some recent enhancements to the `@Reducer` macro,

gave a sneak peek of a _highly anticipated topic_, and answered your questions along the way.

🔒 So what's the point of observation in the Composable Architecture? While we have seemingly

simplified nearly every inch of the library as it interfaces with SwiftUI, let's zoom out a

bit, explore how some integration tests that benchmark certain aspects of the library have

changed, and migrate the Todos application we built in the very first tour of this library to

the new tools.

🔒 We have iterated on how bindings work in the Composable Architecture many times, but have

never been fully happy with the results. With Observation, that all changes. By eliminating

view stores and observing store state directly, we are free to totally reimagine bindings in

the Composable Architecture, and get rid of even more concepts in the process.

🔒 Observation has allowed us to get rid of a number of view wrappers the Composable Architecture

used to require in favor of vanilla SwiftUI views, instead, but we still depend on a zoo of

view modifiers to drive navigation. Let's rethink all of these helpers and see if we can trade

them out for simpler, vanilla SwiftUI view modifiers, instead.