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

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

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

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

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

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

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

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

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

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