CF

Practical Swift Concurrency - The Video Course

4h 45m 41s
English
Paid
Updated September 2026

Practical Swift Concurrency - The Video Course is a 36-lesson 4 hours 45 minutes self-paced course by Donny Wals. Swift's structured concurrency model — async/await, actors, tasks — is easier to absorb watching someone work through it than reading alone, and this roughly 10-hour, 36-lesson video course is built around that idea.

Course facts

Lessons
36
Duration
4 hours 45 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Donny Wals
Price
Premium

Swift's structured concurrency model — async/await, actors, tasks — is easier to absorb watching someone work through it than reading alone, and this roughly 10-hour, 36-lesson video course is built around that idea.

How to use it

It stands on its own, but it's also designed as a companion to the Practical Swift Concurrency book: many learners work through the videos first to get the concepts moving, then use the book afterward as a deeper reference.

Whichever way you approach it, the material sticks to the practical side of Swift concurrency — the patterns and interactive exercises you'd actually use while writing real Swift code, rather than a purely theoretical rundown of the concurrency model.

Who teaches Practical Swift Concurrency - The Video Course? Donny Wals

Donny Wals thumbnail

Donny Wals is a Dutch iOS developer and the author of Practical Combine, Practical Core Data, and Practical Swift Concurrency — books focused on the parts of the Apple platform that the official documentation underexplains. His material is widely respected among working iOS engineers for going deep on the modern Swift concurrency model.

His CourseFlix listing carries Practical Swift Concurrency — The Video Course. Material is paid and aimed at iOS developers ready to use async/await and structured concurrency confidently in production code.

What lessons are included in Practical Swift Concurrency - The Video Course?

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 36 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: About this course
All Course Lessons (36)
#Lesson TitleDurationAccess
1
About this course Demo
02:06
2
Setting up your environment
02:33
3
Exploring the sample app
04:42
4
Understanding async programming pre-async/await
09:33
5
Calling an async function in Swift
08:02
6
Writing an async function in Swift
02:42
7
Exploring Tasks in Swift Concurrency
15:33
8
Assignment: Writing your first async function
03:09
9
Solution: Writing your first async function
15:08
10
Understanding the complexities of refactoring
05:53
11
Bridging callback based code with continuations
03:09
12
Understanding different types of continuations
09:49
13
Bridging Combine code with async sequences
18:05
14
Diving deeper into async sequences with AsyncStream
26:31
15
Assignment: Bridging your first function
02:10
16
Solution: Bridging your first function
04:33
17
Understanding data races
07:41
18
Solving data races with actors
05:35
19
Understanding Actor Reentrancy
13:33
20
Exploring the main actor
13:33
21
Understanding Sendable
17:15
22
Assignment: Building a token refresh flow
02:27
23
Solution: Building a token refresh flow
07:11
24
Bonus: Building an async image loader from scratch
14:58
25
Section Introduction
01:29
26
Understanding async tests pre-Swift Concurrency
05:04
27
Awaiting test results
04:00
28
Testing and async sequences
07:06
29
Understanding why it's hard to test race conditions
11:09
30
Section introduction
01:18
31
Understanding structured concurrency
04:07
32
Exploring Task Groups
14:23
33
Understanding async let
07:43
34
Assignment: Writing a data importer
02:53
35
Solution: Writing a data importer
09:18
36
Thank you!
01:20
Unlock unlimited learning

Get instant access to all 35 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book Practical Swift Concurrency - The Video Course

#TitleTypeOpen
1Practical Swift Concurrency PDF

What courses are similar to Practical Swift Concurrency - The Video Course?

Frequently asked questions

What are the prerequisites for enrolling in this Swift concurrency course?
This course assumes a foundational knowledge of Swift programming. You should be comfortable with basic Swift syntax and concepts, as the course focuses on advanced concurrency topics. Prior experience with asynchronous programming concepts will be beneficial, but the course includes lessons on understanding async programming pre-async/await, which can help bridge any gaps.
What will I build or learn to build in this course?
Throughout the course, you will engage in several practical assignments, such as writing your first async function, bridging functions, and building a token refresh flow. Additionally, there is a bonus project where you will learn to build an async image loader from scratch. These projects are designed to solidify your understanding of Swift concurrency and its application in real-world tasks.
Who is the target audience for this course?
The course is aimed at Swift developers who want to deepen their understanding of concurrency in Swift applications. It is suitable for those who have a basic understanding of Swift and are looking to explore more advanced topics such as async/await, task management, and structured concurrency. Professionals aiming to enhance their skills in modern Swift programming concepts will find this course particularly beneficial.
How does this course compare to the Practical Swift Concurrency book?
While both the course and the book cover similar topics, the course offers a dynamic learning experience through video content and interactive exercises. This can serve as an initial learning pass, allowing learners to visually grasp concepts before delving deeper with the book for detailed understanding and reference. The course stands independently but complements the book for a more comprehensive learning experience.
What Swift concurrency topics are not covered in this course?
The course focuses extensively on Swift concurrency, covering async programming, task management, and structured concurrency. However, it does not delve into topics outside the realm of Swift concurrency, such as general Swift UI programming, network handling outside concurrency context, or non-concurrency-related Swift language features.
How much time should I expect to commit to this course?
The course includes nearly 10 hours of video content, which is exclusive of the time you might spend reading the Practical Swift Concurrency book. Depending on your familiarity with the topics, you may need additional time to complete assignments and exercises, so plan for extra hours beyond the video runtime to fully engage with the material.
How can the skills learned in this course benefit my career?
Mastering concurrency in Swift is a valuable skill for any iOS developer, as it allows you to write more efficient, responsive applications. The course covers essential concurrency concepts such as async/await and actor models, which are increasingly important in modern app development. These skills can enhance your ability to tackle complex problems, making you a more competitive candidate for advanced development roles.