Swift Concurrency Videos
Swift is about to get its Concurrency features. Their development is going very well, with many proposals actively reviewed and a lot of the work already available in recent snapshots. The story is big and with many moving pieces interlinked with each other. That makes it a bit hard to wrap your head around the entire thing. Specially for those that don't read Swift Evolution as a hobby ^^.
But it has hooked me up. There are so many interesting conversations and so much to learn! I've written a big number of notes about the topic and decided that it was worth making a video series to help the community understand what really Swift Concurrency entails.
That's what this series of videos is trying to do. I explain to you parts of the Concurrency story, making it clear how they relate to each other. Some of these concepts can be quite new to a lot of developers so you will also find the theory and story behind them. As always, my goal is not to make tutorials, but to explain to you what things are and why they are how they are. To give you the tools so you can dive deeper into those topics. I just want you to be ready for when all of this lands officially into the language. The Swift programming language inspires these videos, and the examples use it to drive the point home. But the theory and principles widely apply to any other programming language. So I hope that this helps other communities too.
First look at async await
This first video serves as an introduction to the whole Concurrency story, focusing on the new keywords, what they are and what they are not. I also explore how we can bridge between an existing callback system and this new world of async functions, and how this will affect our codabases.
This second video is fully focused on the Actor System. This system is not new, but is not very well known either. That's why I thought it would be very good to explain what Actors are, what's the theory behind them, what problems they solve and what things we need to be careful about.
Structured Concurrency is the underlying topic that pulls the entire Swift Concurrency story together, it brings very important fundamentals that help design the rest of features. But is not something that the everyday programmer has heard about. This video goes into the story and theory behind it, hopefully making it clear to everybody why Swift is going in this direction.
AsyncSequence is a new protocol that aims to cover those cases were we need more than one value to be computed asynchronously. This will remind you to RxSwift and Combine and that's because the principles behind it are the same. How will this be integrated with those frameworks? All of this and more in the video!
Right now these are the four videos of the series. I have a couple of more drafted but with WWDC21 approaching fast I'm not sure I will have enough time to finish them.
If there is any interest in other concurrency topics, feel free to reach out :)
If you liked this article please consider supporting me