Structured concurrency changed the shape of asynchronous Swift: complex flows read top to bottom instead of nesting into callbacks. This is a working tour of the machinery underneath that — starting with Task as the way into an async context from synchronous code, and .task as its SwiftUI counterpart tied to a view's lifetime.
The bulk of it is about cancellation, which is where most real code is wrong: how to stay cancellation-aware, what withTaskCancellationHandler is for, and why swallowing cancellation with try? is a bug rather than a tidy-up. It also covers task priorities, the difference between .task(priority:) and Task.detached(priority:), and awaiting results through .value.
A closing section collects the traps that show up in real-world code: wrapping a cancellable call in try? and losing the thrown CancellationError along with it, letting a task's thrown error disappear instead of surfacing it, and reading a priority hint as a promise about which actor or thread the work actually runs on.
It is explicit about its own scope: child tasks, task groups, task-local values and custom executors are pointed to as the next things to explore rather than folded into this piece.