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

🔒 We can now observe struct, optional, and enum state in the Composable Architecture, but what

about collections? Let's explore what it takes to get rid of the `ForEachStore` wrapper view

for a vanilla `ForEach` view instead, while still observing updates to collection state in the

most minimal way possible.

🔒 We've made structs and optionals observable in the Composable Architecture, eliminating the

need for `ViewStore`s and `IfLetStore`s, so what about enums? If we can make enums observable,

we could further eliminate the concept of the `SwitchStore`, greatly improving the ergonomics

of working with enums in the library.

🔒 The Composable Architecture can now observe _struct_ state, but it requires a lot of boilerplate. Let's fix this by leveraging the `@Observable` macro from the Swift open source repository. And let's explore what it means to observe _optional_ state and eliminate the library's `IfLetStore` view for a simple `if let` statement.

🔒 One of the core tenets of the Composable Architecture is that you should be able to model your

application's state using simple value types, like structs and enums. However, the

`@Observable` macro does not work with value types at all, and so in order to enhance the

Composable Architecture with Observation we will need to contend with this issue and explore

what it means for a struct to be observable.

🆓 We're about to completely revolutionize the Composable Architecture with Swift's new

Observation framework! But first, a sneak peek: we'll take the public beta (available today!)

for a spin to see how the concept of a "view store" completely vanishes when using the new

tools.

Oh, and did we mention that the new observation tools in the library have been backported

all the way back to iOS 13? This means you can use the tools _immediately_. 🤯