🔒 We explore ways to tie the lifetime of an effect to the lifetime of a view, making it possible to automatically cancel and tear down work when a view goes away. This unexpectedly helps us write even stronger tests for our features.

🔒 We introduce another helper to the `Effect` type that can use an asynchronous context to send multiple actions back into the system. By leveraging Swift's structured concurrency we can create complex effects in a natural way, all without sacrificing testability.

🔒 We can now run async work directly in a reducer's effects, but time-based asynchrony, like `Task.sleep`, will wreak havoc in our tests. Let's explore the problem in a new feature, and see how to recover the nice syntax of modern timing tools using a protocol from the past: Combine schedulers.

🔒 This week we start fixing the problems we outlined last week. We build the tools necessary to start using concurrency tasks directly in reducers, and along the way we open Pandora's box of existential types to solve some mind-bending type issues.

🆓 The Composable Architecture's fundamental unit of effect is modeled on Combine publishers because it was the simplest and most modern asynchrony tool available at the time. Now Swift has native concurrency tools, and so we want to make use of those tools in the library. But first, let's see what can go wrong if we try to naively use async/await in an existing application.

🔒 There are amazing features of Swift concurrency that don't quite fit into our narrative of examining it through the lens of past concurrency tools. Instead, we'll examine them through the lens of a past programming paradigm, structured programming, and see what is has to say about structured concurrency.

🔒 When working with concurrent code, you must contend with data synchronization and data races. While the tools of the past made it difficult to reason about these issues, Swift's new tools make it a breeze, including the `Sendable` protocol, `@Sendable` closures, and actors.

🔒 Let’s look at what the future of concurrency looks like in Swift. A recent release of Swift came with a variety of tools with concurrency. Let's examine its fundamental unit in depth, and explore how they "cooperate" in your applications.

🔒 Before developing Swift's modern concurrency tools, Apple improved upon threads with several other abstractions, including operation queues, Grand Central Dispatch, and Combine. Let's see what these newer tools brought to the table.

🔒 To better understand Swift's concurrency tools, let's first look to the past, starting with threads. Threads are a tool most developers don't reach for these days, but are important to understand, and the way they solve problems reverberate even in today's tools.