The 1-hour Swift Concurrency course

Understand the toolset from async/await to modern Swift 6.2

“What’s the best way to learn modern Swift concurrency?” is one of the most common questions in the iOS community. Perhaps the most common question after “should I start with SwiftUI or UIKit?”

I decided to finally come up with a proper answer: shilling my own work.

This is not the most comprehensive course out there (a paltry 6,300 words, hence the catchy title). But this course might be the most information-dense.

We will cover two core pillars:

1. Why Swift concurrency exists, and how it works under the hood.

2. All the tools that are available, and when you should use each one.

This is Jacob’s Tech Tavern. Of course you’re getting an under-the-hood section.

I understand you might be keen to jump straight into code.

Without theoretical understanding, the toolkit is just that: a toolkit. A set of syntax, learned separately and applied haphazardly. When you know the underlying mechanism, you see that they are all part of the same paradigm.

You build an intuition.

The killer instinct that tells you that this is a job for a TaskGroup. That illustrates, at a glance, which lines of code will run on the MainActor versus a background thread. The gut feeling for when an AsyncStream might be appropriate or when a good old-fashioned async let will do.

This course is brimming with backlinks into my other work, plus many blog posts from other writers when I think they explained it better. You can go wild here, recursively opening tabs and absorbing everything at once, or keep this course handy as a reference as you advance your coding career.

Senior-level knowledge of Swift concurrency is all about knowing what exists in the toolkit, and when to apply each tool to the problem at hand. It’s knowing enough about the internal workings to intuit and predict the behaviour of a system in any novel situation.

Without further ado, let’s crack on.

• First, A History Lesson

• How Swift Concurrency Works Under The Hood

  • The Cooperative Thread Pool

  • Executors

  • Tasks, Threads, and Continuations

  • Bringing These Concepts Together

• The Swift Concurrency Toolkit

  • Tasks

  • Async Await

  • Async Let

  • Task Groups

  • Actors

  • MainActor

  • Swift 6.2 Default Actor Isolation

• Advanced Swift Concurrency

  • Continuations

  • Sendable and Memory Safety

  • Swift 6.2 Approachable Concurrency

  • Task Hierarchy, Cancellation and Actor Context Inheritance

  • Async Sequence & Async Stream

  • Async Algorithms

  • Testing your Async code

  • Distributed Actors

• Last Orders

Subscribe to Jacob’s Tech Tavern for free to read ludicrously in-depth articles on iOS, Swift, tech, & indie projects in your inbox every week.

Paid subscribers get much more:

• Access this full Swift Concurrency course 🧵

• Read Elite Hacks, my exclusive advanced content 🌟

• See my free articles 3 weeks before anyone else 🚀