Modern Concurrency: Beyond the Basics

00:01Hi, I’m Audrey. Welcome to our course Modern Concurrency: Beyond the Basics. In this video, you’ll find out what’s in store for you as you work through this course.

00:11This course follows on from Modern Concurrency: Getting Started and assumes you’re familiar with what that course covers You should be comfortable calling and writing async functions and iterating over asynchronous sequences.

00:26In Part 1, you’ll learn about AsyncStream, unit testing & continuations. Part 2 introduces TaskGroup for truly dynamic concurrency and goes beyond MainActor, to show you how to use the Actor API to make your code thread-safe.

00:46Now, I’ll tell you a little more about the topics in Part 1.

00:49Whenever Apple introduces something new, like Swift or SwiftUI, they don’t expect developers to stop using the old way and switch completely over to the new. There are always bridging tools to make it easier to integrate existing code with the new stuff.

01:06AsyncStream is one of these tools: You can use it to create async sequences from the completion handlers and delegate methods of existing asynchronous APIs.

01:18You’ll also learn how to use AsyncStream to create custom asynchronous sequences without adding new types to your app. You just specify the element type, then supply a trailing closure to provide the sequence.

01:34There are two types of closure. You’ll use one type to create a countdown sequence and the other type to stream notifications.

01:43Since Apple first introduced Grand Central Dispatch, it has advised developers on how to avoid the dangers of thread explosion.

01:51In the Swift concurrency system, there are at most only as many threads as there are CPU cores. When threads execute work under Swift concurrency, the system uses a lightweight object known as a continuation to track where to resume work on a suspended task.

02:11When a task suspends, it captures its state in a continuation. Its thread can resume execution of another task, recreating its state from the continuation it created when it suspended. The cost of this is a function call. Switching between task continuations is much cheaper and more efficient than performing context switches.

02:34This all happens behind the scenes when you use async functions. But you can also get your hands on a continuation to manually resume execution. The buffering form of AsyncStream uses a continuation to yield stream elements. And you’ll use a manual continuation API to help you convert existing code like completion handlers and delegate methods into async functions.

03:02Before Swift concurrency, XCTest didn’t have language support for running asynchronous code. You had to rely on workarounds like XCTWaiter and expectations. With Swift concurrency, you just declare any test method as async. When you await an asynchronous function, the test suspends. When it resumes, you can verify the output as usual.

03:26You’ll work through a simple test case with a single await and a more complex one that captures test output over time.

03:35You’ll also create some tools to create tasks that time out instead of hanging and also speed up task duration.

03:43The app you’ll work on in Part 1 is a messaging app called Blabber. The starter project already implements the basic chat view:

• 03:51You’ll implement a countdown timer using both AsyncStream closure types.

• 03:56Then you’ll use the buffered AsyncStream to add notifications when a user leaves or returns.

• 04:04You’ll use continuations with CoreLocation to let users show their location.

• 04:09And you’ll learn how easy it is to write unit tests for Blabber’s networking code.

04:13Here’s what you need to work through these courses:

• 04:16A Mac running macOS Monterey (12.0) or later. Big Sur should work, but this course uses macOS Monterey, so your mileage may vary.

• 04:26Xcode 13: Since Xcode 13.2, all the new Swift concurrency features work with iOS 13 / macOS 10.15 SDK (or later). If you use an older version of Xcode 13, you’ll only get Swift concurrency support when targeting iOS 15 / macOS 12.

• 04:51Intermediate level of Swift: You’ll appreciate Swift concurrency more if you’re familiar with Grand Central Dispatch and URLSession. And you’ll be doing a lot of throwing and do-try-catching errors.

• 05:03SwiftUI: The sample projects have all the views and navigation code in place, but you should have some familiarity with SwiftUI. You’ll need to add a few view modifiers and actions to call your asynchronous methods from SwiftUI views.

• 03:18Basics of async/await and AsyncSequence, equivalent to the Getting Started course.

05:23This course is based on the book by the amazing Marin Todorov. He’s icanzilb on Twitter.

05:29This video series has been tech edited by Adrian Strahan. Find him on twitter as adrianstrahan.

05:35In the next episode, you’ll explore AsyncStream in a playground. Then you’ll use what you learned in the Blabber app.