Donny Wals 👾
@donnywals.bsky.social
2.2K followers 470 following 880 posts
iOS Engineer, blogger and author at https://donnywals.com. Loves learning and sharing knowledge. -- #swift #ios #swiftlang #iosdev #solopreneur (he/him)
Posts Media Videos Starter Packs
donnywals.bsky.social
😱 Was a pleasure man! Hope to see you again in the future
donnywals.bsky.social
Dive into Swift 6.2's concurrency updates! Learn about nonisolated async functions, @Concurrent, and Xcode 26's new concurrency defaults. Boost your iOS skills with practical insights. Watch here: https://www.youtube.com/watch?v=7QvCFBNz45A
What's new for concurrency in Swift 6.2
Swift 6.2 is now officially in beta and so it's time for me to talk about what's new in concurrency for Swift 6.2. This video is a companion for my blog post on the same topic: https://www.donnywals.com/exploring-concurrency-changes-in-swift-6-2?utm_source=youtube In this video you will learn about nonislated(nonsending), and how it will make nonisolated async functions run on the actor that they were called from by default. You'll learn why this matters, and how you can use @Concurrent to offload work to a background thread. You'll also see how you can enable this feature from within Xcode's build settings directly. After that, we'll take a look at the new concurrency default in Xcode 26 that will make all your code run on the main actor by default. You'll learn how you can control default actor isolation by either setting it to MainActor or nonisolated, and you'll learn how this simplifies the way your code works. We'll also talk about how you can opt-out of this feature on a type- and function level. Strengthen your iOS development skills with my books: https://gumroad.com/l/practical-combine?utm_source=youtube https://gumroad.com/l/practical-core-data?utm_source=youtube https://gumroad.com/l/practical-swift-concurrency?utm_source=youtube https://gumroad.com/l/practical-bundle?utm_source=youtube Timestamps 00:00 - intro 00:56 - function types in Swift 6.1 04:21 - calling functions from the main actor 07:53 - calling functions from the global executor 09:34 - introducing nonisolated(nonsending) 10:10 - demonstrating actor inheritance 11:12 - introducing @concurrent 15:46 - introducing default actor isolation 21:11 - summary
www.youtube.com
donnywals.bsky.social
A good morning and happy Monday, folks! Hope you're all having a good start of your week. Do you have any plans? Are you working on something cool? Learning something new? Anything at all, tell me all about it 😎
donnywals.bsky.social
Did you know that Approachable Concurrency in Xcode 26 enables a set of Swift features that make getting started with Concurrency much easier than it was before? Read about it here: https://www.donnywals.com/what-is-approachable-concurrency-in-xcode-26/
donnywals.bsky.social
Do you know what Structured Concurrency is in Swift? If you're not exactly sure how Structured Concurrency fits in Swift's Concurrency model, catch up here: https://www.donnywals.com/the-basics-of-structured-concurrency-in-swift-explained/
donnywals.bsky.social
Explore the essentials of migrating to Swift 6, find out what to expect and how you should prepare your team. Watch here: https://www.youtube.com/watch?v=YNBkp8L_j5M
How to plan a migration to Swift 6?
Learn how you can start migrating over to Swift 6 in a responsible manner. Async/Await is super nice in Swift but at the same time it's essential that you plan a migration to Swift 6 carefully. With a completely new concurrency paradigm you'll run into tons of errors that are not familiar. It's rather easy to go overboard with the amount of concurrency that you're adding to your app, and you'll want to make sure that your team is up to speed when it comes to everything that's in Swift Concurrency. This video is a companion for my blog post on the same topic: https://www.donnywals.com/how-to-plan-a-migration-to-swift-6?utm_source=youtube Learn more about @preconcurrency and how it helps you migrate: https://www.youtube.com/watch?v=0Zf5zgtK-RU Improve your concurrency skills with my book, workshops, and course: https://practicalswiftconcurrency.com?utm_source=youtube https://donnyplus.com/p/practical-swift-concurrency-the-video-course?utm_source=youtube https://www.donnywals.com/workshops?utm_source=youtube Timestamps: 00:00 - Intro 01:03 - Taking inventory of your codebase 03:01 - Modularizing your codebase 04:25 - Strict concurrency checking 06:31 - Training your team 08:33 - Planning your approach 10:45 - Pitfalls and caveats 12:38 - Summary
www.youtube.com
donnywals.bsky.social
If you've ever felt like you weren't knowledgeable enough to participate in a conversation, so have I. And to be honest, I still feel that way regularly.

I reflect on this and more in this week's newsletter: https://www.donnywals.com/newsletters/4cHkurGuhPUE45uIhV4uVw/
donnywals.bsky.social
Last week's blog post was a deep dive into unwrapping [weak self] in your Swift Concurrency Tasks and how common it is for folks to not introduce the behavior they were looking for: https://www.donnywals.com/how-to-use-weak-self-in-swift-concurrency-tasks/
donnywals.bsky.social
My blog post on Swift's actors hadn't seen much updates recently so I figured it could use some modernization. Check it out here: https://www.donnywals.com/actors-in-swift-explained-with-examples/
donnywals.bsky.social
Last week's video is a deep dive into some of the mistakes I frequently see when folks unwrap a [weak self] in their Swift Concurrency tasks...

See if you make the same mistake: https://www.youtube.com/watch?v=xpAj1xFyvGM
donnywals.bsky.social
In last week's newsletter I wrote about how Swift 6.2 has me thinking about how frequently the code we write and the patterns we follow are the result of our own "default" behaviors rather than being fully thought out...

Read here: https://www.donnywals.com/newsletters/yVt9Cu8UsoCm892UaNZXaGUA/
donnywals.bsky.social
I'm convinced typos stay hidden until you hit send and can't make changes anymore, that's when they show themselves
donnywals.bsky.social
It's been two weeks since I've launched the Swift 6.2 update for Practical Swift Concurrency and folks seem to be enjoying the update a lot.

Huge thank you for everybody that's downloaded the book ❤️

https://gumroad.com/l/practical-swift-concurrency
donnywals.bsky.social
A good morning and a happy Monday, folks! Hope you've all had a nice weekend.

Do you have any plans for the week? Maybe learning something new, working on something cool, shipping something you've been working on?

Tell me all about it! 😎
donnywals.bsky.social
You might be unwrapping [weak self] in your Tasks in a way that mitigates the reason you're using [weak self] in the first place. It's actually a pretty common issue that I've seen in several codebases...

Learn everything you need to know and more in t... https://www.youtube.com/watch?v=xpAj1xFyvGM
donnywals.bsky.social
No because deinit will never get called until the task completes.

The guard let self at the start of the task makes a strong reference to self again.

One way to fix this is to unwrap self in the while loop instead. That way each iteration creates and releases its own strong reference
donnywals.bsky.social
Decided to write up a version of this post that doesn’t involve sequences and solely focuses on issues that you can run into with having a weak self capture in a Task: www.donnywals.com/how-to-use-w...