Goodbye GCD: Embracing async/await in Your SwiftUI Journey

This is the introduction to explaining asynchronous/await

This lecture explores the core reasons why async/await, despite its clean syntax and modern design, can be difficult for beginners to grasp—especially those new to concurrency and threading. We unpack how its seemingly synchronous structure hides complex asynchronous behavior, and how the suspension and resumption model requires a shift in thinking.

The session contrasts async/await with DispatchQueue, highlighting how the latter’s explicit thread management provides a clearer mental model for understanding execution flow. By examining how thread context is handled differently, and how structured concurrency abstracts many of the manual responsibilities, students will gain a deeper appreciation for the power and pitfalls of async/await.

Ideal for developers transitioning from UIKit to SwiftUI, this lecture sets the foundation for confidently adopting Swift’s structured concurrency model.

This lecture explores the core aspects of manual control in asynchronous programming, with a focus on how developers explicitly manage execution flow using tools like DispatchQueue. Topics include thread selection, queue prioritization, manual switching between background and main threads, and safeguarding UI updates. By examining these responsibilities in depth, students will gain an appreciation for both the flexibility and complexity of manual concurrency models—setting the stage for understanding how structured concurrency (via async/await) simplifies these same concerns.

In this video, we demystify Swift's async/await by directly comparing it to the more familiar DispatchQueue approach. Aimed at developers transitioning from UIKit to SwiftUI, the video walks through how both methods handle asynchronous tasks, thread context, and UI updates.

By examining common concurrency patterns side-by-side—like network calls, background processing, and main thread updates—you'll see how DispatchQueue requires manual thread management, while async/await offers a cleaner, more structured alternative. The video highlights key concepts such as thread switching, callback hell, and race conditions, and shows how Swift's modern concurrency model solves these challenges with simpler, more readable code.

Ideal for anyone looking to move from imperative to declarative Swift, this session builds your mental model of structured concurrency by grounding it in tools you already understand.

FYI, there is a resources attachment with a link to the GitHub repo.

This lecture focuses on the real-world use of Swift's actor keyword as a solution to managing shared mutable state safely in concurrent environments. Through concrete examples, such as building a thread-safe in-memory cache and a shared counter, students will learn how actors isolate data, serialize access, and eliminate race conditions without relying on locks or manual thread management.

The session compares traditional approaches using DispatchQueue with the actor-based model, highlighting the benefits of structured concurrency in terms of readability, maintainability, and safety. By the end of the lecture, learners will understand when and how to use actors effectively, and how they fit into the broader Swift Concurrency model.

This lecture presents a clear, practical comparison between two common approaches to managing concurrency in Swift: DispatchQueue and actor. Through side-by-side examples, learners will see how each method handles thread safety, data access, and synchronization. The session examines a shared use case—a thread-safe counter—implemented using both techniques to highlight the differences in complexity, readability, and error risk.

By analyzing how DispatchQueue requires manual thread management and potential for race conditions, versus how actor simplifies and enforces safe access through structured concurrency, students will gain a deeper understanding of Swift’s evolving concurrency model. This lecture is ideal for developers familiar with Grand Central Dispatch who want to transition to Swift’s modern concurrency tools with confidence.