Alan Swift Concurrency for Swift 6 (Part-1)

Swift Concurrency for Swift 6 (Part 1) ✍🏻

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

🌿🌿🌿

Solid fundamentals based on computer science and
the subtle differences in detail
are what I believe create differences in skill.

🌿🌿🌿

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

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

Therefore, this course was designed with the goal of gradually moving toward Swift 6 and learning everything related to Swift Concurrency—in other words, everything from A to Z. Please refer to the main content of this course below. I also explain the course in detail in the introduction video for the first lecture, so please refer to that as well.

(Upon completing Part-2, I believe you will have built a theoretical foundation for adopting Swift 6.)

It has always been a personal goal of mine, but this course covers more detailed and in-depth content than any other Swift Concurrency course in the world. (I believe that the fine details, down to the point of obsession, make the difference in skill, so I always strive to provide a variety of code examples and well-organized materials.)

What this course covers 🕵🏻‍♂️👨🏻‍🎓

(1) Main topics covered in Part - 1 (this course) ⭐️⭐️⭐️

• A Proper Understanding of Task / async / await

  
  

• How asynchronous (async) functions work

• Introduction to New Asynchronous APIs Related to URLSession

• Using Continuations (1) Converting callback functions / (2) Converting the delegate pattern to an asynchronous approach

• Project example: Converting the delegate-based approach of the Location app (CoreLocation) to async/await

• Theoretical content on 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

• Applications of TaskGroup (Specifying the Number of Concurrent Threads – Custom Configuration)

• Using Task-Local Variables

(2) (Coming soon) Topics that will be covered primarily in Part 2 (separate 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 Safe to Share Between Threads)

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

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

• Global Actors and the Main Actor

• Implementing a cache with an actor — Project Example

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

• Applying AsyncStream to WebSockets — Project Example

• Transferring (sending) a Non-Sendable type

• Isolation-related issues with functions (closures) — isolated (Actor)? = #isolation / @isolated(any)

• Implementing a Custom Executor / Task Executor Preference

• (Reference) The consume / consuming keywords

• Advanced Actor Syntax Rules - Initializers / Deinitializers / Protocols / Inheritance / Extensions

• Moving from Swift 5 to Swift 6

• Analyze the project using Instruments

  
  

  
  

  Part-2 Course Link: https://inf.run/TyZcJ

  
  

Features of This Course

📌 We aim to cover Swift Concurrency programming from A to Z.

📌 It lays the foundation for writing safe code across multiple threads from compile time onward (the goal of Swift 6).

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

📌 We analyze numerous international books, courses, and other resources related to Concurrency to cover as much of the content as possible without leaving anything out.

📌 Various example projects

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

📌 (As has always been the case with my courses,) I provide separate study materials for the most intuitive understanding and organized learning possible.

The best materials for learning are provided.

Notes Before Enrolling in the Course

💌Regarding the license for the course content

For the content of this course, whenever I referred to even a small amount of material such as images, the PDF includes the relevant URL. Except in such cases, all materials were created by me, so under no circumstances may you include the content of this course in a blog or share the PDF file of the e-book used as the course material.

(Please be aware that violating these license terms may result in legal liability.)