Get 20% off on all the courses
This isn’t just about syntax — it’s about thinking like a modern iOS architect. You’ll gain a deep, practical understanding of Swift’s concurrency model, empowering you to build fast, fluid, and scalable apps with confidence
Concurrencies
Most developers use concurrency — few truly understand it. This course unlocks what others miss: how Swift Concurrency really works under the hood, and how to use it to write safe, efficient, modern
async code in the real world. You’ll not only master the async/await syntax — you’ll develop the instinct to architect concurrent tasks without bugs, data races, or
broken UI.
4+ Hours 4K 60fps Videos, 27 GB Content
Real-world examples
Experienced iOS developers
Course Syllabus
Introduction - What is Concurrency, Synchronous vs Asynchronous Execution
Async / await
Task, Task Priorities
.task - Creating Child Tasks and Cancelling Tasks
Continuation
Async let
Task Group
Data Race
Blocking Main Thread, Dive deep with Instrument Profiler
Blocked Main Thread resolution using Actor and nonisolated keywords
More... ⬇️
What You’ll Learn
Swift Concurrency: Introduction: Start here and never look back. Learn what concurrency actually is — not just theoretically, but practically. You'll understand why async
programming matters, how synchronous and asynchronous
execution work under the hood, and where most developers go wrong.
Async / Await: The elegant syntax hides deep complexity — and you’ll master both. Understand structured concurrency, suspension points, and how async/await rewires your code to be safer, cleaner, and smarter
Async let: Parallelism made easy — but only if used right. You’ll learn how async let lets you fire off multiple async operations in parallel, and what hidden performance traps to avoid when awaiting too late or too early
Data Race: Most devs don’t even know it’s happening. You’ll learn what a data race really is, how concurrency introduces it, and how to spot and avoid it before it destroys your app’s reliability
Actors and the nonisolated Keyword: Your secret weapon against shared state and race conditions. Learn when and how to use actor, what nonisolated really means, and how to write thread-safe logic without complexity or confusion
Task and Task Priorities: Not all tasks are equal — and Swift gives you control. Learn how to create, manage, and prioritize Task instances, while understanding how task priorities affect real-world execution on Apple devices.
.task Modifier and Child Tasks: The .task modifier seems simple — but it has powerful implications. You’ll learn how Swift creates child tasks, how they inherit context, and how to cancel or isolate them safely — a topic often misunderstood and rarely taught well
Task Group: Level up to concurrent orchestration. Learn how to manage dynamic groups of tasks that run in parallel — and how to handle Cancellation, error propagation, and result aggregation in a way that’s clean, efficient, and safe.
Blocking the Main Thread + Instrument Profiler Deep Dive: Learn to recognize and resolve main-thread blocking with Apple’s Instruments Profiler. You’ll uncover hidden performance bottlenecks and build the skill to analyze, measure, and optimize UI responsiveness like a pro.