Mastering Swift Concurrency (part 2)

Swift’s concurrency model has fundamentally changed how we write safe, performant asynchronous code.

This intensive workshop is designed for intermediate to advanced Swift developers who want to master concurrency beyond the basics. If you’ve dabbled with async/await but struggle with actor isolation errors, wonder what “Sendable” really means, or need to migrate production code to Swift 6 strict mode, this workshop will give you the deep understanding and practical skills you need.

You’ll learn:

The fundamentals of Swift’s concurrency model: async/await, Tasks, and structured concurrency
How actors create isolation domains and protect shared mutable state at compile time
The Sendable protocol: what can cross isolation boundaries and why it matters
@MainActor and global actors: guaranteeing UI operations happen on the main thread
Actor reentrancy: the surprising behavior that catches everyone off guard
Swift 6’s strict concurrency checking: what it catches and how to fix violations
Approachable Concurrency in Swift 6.2 — how it smooths your migration path
Isolation domains: the mental model that makes everything click
Migration strategies for bringing existing codebases to Swift 6 strict mode
Real-world patterns for networking, caching, and concurrent operations

What makes this workshop different is the hands-on approach. We’ll build a complete multi-threaded image downloader app that demonstrates every major concurrency pattern.

You’ll implement parallel downloads with progress tracking, use actors to manage shared state safely, handle cancellation properly, and see exactly how isolation prevents data races. Then we’ll enable Swift 6 strict checking and systematically fix every violation—giving you practical experience with the errors you’ll encounter in real projects.

This isn’t a theory-heavy lecture. After a focused 30-minute presentation covering core concepts, you’ll spend two hours writing code, encountering real concurrency challenges, and implementing proper solutions. You’ll make mistakes in a safe environment, understand why the compiler is complaining, and learn the patterns that actually work.

Swift 6’s strict concurrency is the future of safe concurrent programming in Swift. This workshop gives you the skills to embrace it confidently, migrate existing code successfully, and build the next generation of robust, race-free Swift applications.