Alan Swift Concurrency for Swift 6 (Part-2)

Swift Concurrency for Swift 6 (Part - 2) ✍🏻

Subtitle: Properly Learning Swift Concurrency Programming to Move Forward with Swift 6

🌿🌿🌿

A solid foundation based on CS and
the detailed nuances
make the difference in skill.

🌿🌿🌿

Swift introduced new concurrency programming (Swift Concurrency) in version 5.5, and after going through step-by-step preparations, it has finally been updated to version 6. And one of the core goals of Swift 6 is to eliminate potential data races (Race Condition/Data-Races) and ensure safety by enabling the implementation of Thread-Safe code from the compilation stage.

(We are at a turning point for the gradual adoption of Swift 6.)

Therefore, this course is designed to gradually move toward Swift 6, with the goal of learning everything from A to Z related to Swift Concurrency. Please refer to the main content of this course below, and the first introductory video provides a detailed explanation of the course, so please check that as well.

(Once you complete all the content up to Part-1 / 2, you will have established the theoretical foundation for adopting Swift 6.)

It's always a personal goal for my lectures, but this course covers more detailed and in-depth content than any other Swift Concurrency course on Earth. (I believe that obsessive attention to detail and subtle differences make the difference in skill level, so I always strive to provide various code examples and well-organized materials.)

(2) Part - 2에서 주로 다루는 내용 [[SPAN_1]](본 강의) [[/SPAN_1]]⭐[[SPAN_2]]️[[/SPAN_2]]⭐[[SPAN_3]]️[[/SPAN_3]]⭐

• Concurrent Programming: Understanding from a Computer Science Perspective (Understanding Threads/Memory Structure)

• Data Isolation / Task Isolation / Actor Isolation (Understanding Isolation Concepts)

• # Task Isolation and Shared Mutable State

• Sendable Type (Data Types Safe to Share Between Threads)

• # Complete Guide to Actors (1) Isolation/Non-isolation (2) Atomicity (3) Reentrancy (4) Actor Hopping

• (5) Main Actor Blocking (6) Resolving Actor Conflicts

• Global Actor and Main Actor

• Implementing Cache with Actors: Project Example

• AsyncSequence (Asynchronous Sequence) and AsyncStream (Asynchronous Stream)

• Applying AsyncStream to WebSocket Project Example

• # Sending Non-Sendable Types

• Function (Closure) Isolation Issues - isolated (Actor)? = #isolation / @isolated(any)

• # Implementing Custom Executors / Task Executor Preferences

• # Reference: consume / consuming keywords The `consume` and `consuming` keywords are used in React Query (TanStack Query) to control how queries interact with cached data and manage their lifecycle. ## consume keyword The `consume` keyword is used to specify how a query should handle cached data: - **`consume: true`**: The query will "

• Actor Grammar Rules Deep Dive - Initializers / Deinitializers / Protocols / Inheritance / Extensions

• Transitioning from Swift 5 to Swift 6

• Analyzing Projects Using Instruments

(1) Content mainly covered in Part - 1 (existing lectures)

• # Proper Understanding of Task / async / await

  
  

• The operation method of asynchronous (async) functions

• Introduction to New Asynchronous APIs for URLSession

• Using Continuation: Converting (1) Callback Functions / (2) Delegate Patterns to Asynchronous Approach

• # Example Project: Converting CoreLocation Delegate Pattern to async/await This example demonstrates how to convert CoreLocation's delegate-based API to a modern async/await pattern, making location handling code more readable and maintainable. ## Traditional Delegate Pattern ```swift import CoreLocation class LocationManager: NSObject, CLLocationManagerDelegate { private let manager = CLLocationManager() private var locationContinuation: CheckedContinuation? override init() { super.init() manager.delegate = self } func requestLocation() async throws -> CLLocation { return try await withCheckedThrowingContinuation { continuation in self.locationContinuation = continuation manager.requestLocation() } } // Delegate methods func location

• The theoretical content of structured concurrency

• Parallel Processing - (1) async let (2) TaskGroup

• Understanding How Task Cancellation Works (Project Examples Related to Task Cancellation)

• Understanding the Cooperative Cancellation Model

• Application of Structured Concurrency and Task Cancellation

• Application of TaskGroup (Specifying the Number of Concurrent Threads - Custom Settings)

• # Utilizing Task-Local Variables

Part-1 Course Link: https://inf.run/jXpfH

The Features of This Course

📌 The goal is to cover Swift Concurrency programming from A to Z.

📌 This serves as the foundation for writing thread-safe code at compile time (which is Swift 6's goal).

📌 This course is created by thoroughly analyzing all existing WWDC videos related to Swift Concurrency.

📌 This course was created by referencing all existing Swift Evolution documents (github).

📌 We analyze numerous overseas books, lectures, and other materials related to Concurrency to cover all content as comprehensively as possible without omission.

📌 Various Example Projects

📌 So more detailed than any Swift Concurrency course on Earth !!!!

📌 (As always with my lectures) I provide separate learning materials for the most intuitive understanding and organization.

We use the best materials for learning.

Notes Before Taking the Course

💌 Regarding Course Content License

The content of this course has related URLs in the PDF when I have referenced any images or materials. Except for such cases, all materials are created by me, so posting the course content on blogs and sharing the e-book textbook PDF files used as course materials are prohibited under any circumstances.

(If you violate these license-related terms, you may be held legally liable, so please be sure to take note.)