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

🌿🌿🌿

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 gone through several stages of preparation and has finally been updated to version 6. One of the key goals of Swift 6 is to ensure safety by eliminating the potential for data races (Race Condition/Data-Races) in code and enabling the implementation of thread-safe code from the compilation stage.

(We are at a turning point in 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 topics 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.

(Once you have completed all the content in Parts 1 and 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 subtle differences in attention to detail, almost to the point of obsession, are what create differences in skill, so I always strive to provide a variety of code examples and well-organized materials.)

(2) The main topics 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 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

• Function (Closure) Isolation Issues - 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

• Transitioning from Swift5 to Swift6

• Analyzing a Project Using Instruments

(1) Main topics covered in Part 1 (existing course)

• Properly Understanding Tasks / async / await

  
  

• How asynchronous (async) functions work

• Introduction to the New Asynchronous APIs Related to URLSession

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

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

• Theoretical concepts 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

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

• Using Task-Local Variables

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

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 starting at compile time (the goal of Swift 6).

📌 This course was created through an in-depth analysis of all existing WWDC videos related to Swift Concurrency.

📌 This course was created with reference to all existing Swift Evolution documents (GitHub).

📌 It analyzes numerous international books and courses on Concurrency and covers as much of the material as possible without leaving anything out.

📌 Various example projects

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

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

Use the best resources for learning.

Notes Before Enrolling

💌Regarding the license for the course content

For any content in this course where I referred to even a small amount of imagery or other material, the PDF has the relevant URL addresses left in it. Except in such cases, all materials were created by me, so under no circumstances may you post the content of this course on a blog or share the PDF file of the e-book textbook used as the course material.

(Please be aware that violating the terms related to this license may result in legal liability.)