Allen Swift Concurrency for Swift 6 (Part-2)

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

Subtitle: Properly learning Swift Concurrency to move forward with Swift 6

🌿🌿🌿

I believe that a solid foundation based on CS
and that detailed, subtle difference
are what set skill levels apart.

🌿🌿🌿

Since the introduction of new Swift Concurrency in version 5.5, Swift has undergone step-by-step preparations and has finally been updated to version 6. One of the core goals of Swift version 6 is to guarantee safety by eliminating the potential for data races (Race Condition/Data-Races) and enabling the implementation of thread-safe code from the compilation stage.

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

Therefore, this course is designed with the goal of gradually moving toward Swift 6 by learning everything related to Swift Concurrency—that is, from A to Z. Please refer to the main contents of this course below, and since the first course introduction video explains the details of the curriculum, please refer to that as well.

(Once you have completed both Part-1 and Part-2, I believe you will have established the theoretical foundation necessary for the adoption of Swift 6.)

As is always my personal goal for my lectures, I cover more detailed and in-depth content than any other Swift Concurrency-related lecture on Earth. (Because I believe that a single point of detail, akin to an obsession, makes the difference in skill, I always strive to provide various code examples and well-organized materials.)

(2) Main contents covered in Part - 2 (This course) ⭐️⭐️⭐

• Understanding concurrent programming from a Computer Science perspective (Understanding thread/memory structures)

• Data Isolation / Task Isolation / Actor Isolation (Understanding the concept of isolation)

• Task Isolation and Shared Mutable State (Shared Data)

• Sendable Types (Data types that are safe to share across threads)

• Mastering Actors (1) Isolation/Non-isolation (2) Atomicity (3) Reentrancy (4) Actor Hopping

• (5) Blocking the MainActor (6) Resolving Actor Contention

• Global Actors and MainActor

• Project example: Implementing a cache with Actors

• AsyncSequence and AsyncStream

• Project example: Applying AsyncStream to WebSockets

• Sending non-Sendable types (sending)

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

• Implementation of Custom Executors / Task Executor Preference

• (Note) consume / consuming keywords

• Advanced Grammar Rules for Actors - Initializers / Deinitializers / Protocols / Inheritance / Extensions

• Moving from Swift 5 to Swift 6

• Analyzing projects using Instruments

(1) Main contents covered in Part - 1 (Existing lecture)

• Proper understanding of Task / async / await

  
  

• How asynchronous (async) functions work

• Introduction to new asynchronous APIs related to URLSession

• Use of Continuation: Converting (1) Callback functions / (2) Delegate patterns into asynchronous patterns

• Project example of converting the CoreLocation delegate pattern to async/await

• Theoretical content of structured concurrency

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

• Understanding how task cancellation works (Project example related to task cancellation)

• Understanding the Cooperative Cancellation Model

• Applications of Structured Concurrency and Task Cancellation

• Application of TaskGroup (Specifying the number of concurrent threads - custom settings)

• Utilization of Task-Local Variables

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

Features of this course

📌 It has the goal of covering Swift Concurrency programming from A to Z.

📌 It serves as the foundation for writing code that is safe across multiple threads starting from compile time (which is the goal of Swift 6).

📌 This is a lecture created by perfectly analyzing all existing WWDC videos related to Swift Concurrency.

📌 This course was created by referring to all existing Swift Evolution documents (GitHub).

📌 By analyzing numerous international books and lectures on Concurrency, I cover almost everything without leaving anything out.

📌 Various example projects

📌 So, it is more detailed than any other Swift Concurrency course on Earth !!!!

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

We use the best materials for learning.

Notes before taking the course

💌 Regarding the Lecture Content License

Regarding the contents of this lecture, if I have referenced any illustrations or materials, the relevant URLs are provided in the PDF. Except for those cases, all materials were created by me; therefore, posting the contents of this lecture on a blog or sharing the e-book PDF files used as lecture materials is strictly prohibited under any circumstances..

(Please be aware that you may be held legally liable if you violate these license-related terms.)