WWDC 2024: Apple Intelligence and the Swift 6 Concurrency Revolution

Host: Alex Chan Hey everyone, welcome back to Allur! I’m your host, Alex Chan. If you’ve been following the tech world lately, you know that June usually means one thing: Apple’s Worldwide Developers Conference. But honestly, WWDC 2024 felt... different. Usually, we get a few new UI tricks, maybe a new framework to play with, and some flashy hardware. But this year? This year felt like a foundational shift. It wasn't just incremental; it felt like Apple was handing us a new set of rules for the next decade. We’re talking about two massive pillars: Apple Intelligence—their take on generative AI—and the official arrival of the Swift 6 concurrency revolution. These two things together are going to change how we think about building apps, from the way users interact with Siri to the very way we write a single line of asynchronous code. It’s a lot to digest, which is why I’ve brought in a heavy hitter to help us navigate the "beta season" madness. Host: Alex Chan Joining me today is Jordan Miller. Jordan is a veteran iOS Architect and a long-time friend of the show who has spent the last few weeks buried in documentation and Xcode betas. Jordan, it is so good to have you back on Allur. Guest: Jordan Miller Thanks, Alex! It’s great to be here. And yeah, "buried" is definitely the right word. My MacBook fans haven't stopped spinning since the keynote ended. It’s been a wild ride exploring what’s under the hood this year. Host: Alex Chan I bet! Okay, so let’s dive right into the big one: Apple Intelligence. We’ve seen the demos—the Genmojis, the writing tools, the smarter Siri. But for us developers, the "meat" of this seems to be the App Intents framework. Why is that suddenly the star of the show? Guest: Jordan Miller Oh, man, it’s huge. Honestly, if you’re a developer and you haven't looked at App Intents yet, you need to start yesterday. In the past, App Intents were kind of... well, they were for Shortcuts or the Action button. A bit of a niche feature, right? But with Apple Intelligence, App Intents have become the "language" that the system speaks. When Siri wants to perform an action inside your app—like "Send this PDF to Alex"—it doesn't just "click" a button in your UI. It looks for a defined Intent. Host: Alex Chan So, it’s almost like we’re building an API for our own apps that the OS can call? Guest: Jordan Miller Exactly! It’s a structured way to say, "Hey Apple Intelligence, here is a specific thing my app can do." And the "aha moment" for me was realizing that the LLM—the Large Language Model running on the device—uses these intents to understand context. If you don't have well-defined Intents, your app is essentially invisible to the coolest parts of the new Siri. You’re left out of the party. Host: Alex Chan That sounds like a lot of work for teams that maybe ignored Shortcuts for the last three years. Was it a struggle for you to map out those capabilities? Guest: Jordan Miller Actually, yeah, it’s a bit of a mental shift. You have to think about your app’s features as "atomic actions." Instead of "The user navigates to the settings screen to toggle a feature," it’s "The app has a 'Toggle Feature' intent." The real struggle is the description and the metadata. You have to provide clear, natural language descriptions so the system knows *when* to trigger that intent. If your descriptions are vague, Siri just gets confused and says, "I can't do that." Host: Alex Chan Interesting! It’s almost like SEO, but for your app’s functionality. Guest: Jordan Miller (Laughs) That’s a perfect way to put it! "Intent Optimization." Host: Alex Chan Okay, so that’s the "AI" side of things. But while everyone was talking about Genmojis, a lot of us in the developer community were low-key vibrating with anxiety—or excitement—about Swift 6. We’ve been hearing about "Data Safety" and "Strict Concurrency" for a while now. Is the revolution finally here? Guest: Jordan Miller It’s here, Alex. And it’s... it’s a lot. Swift 6 is probably the most significant update to the language since Swift 3’s "Great Renaming." The big headline is "Full Data Isolation" by default. Host: Alex Chan For those who aren’t knee-deep in compiler errors every day, what does that actually mean in practice? Guest: Jordan Miller Okay, so you know those "Heisenbugs"? Those weird crashes that only happen once every thousand times because two different parts of your code tried to change the same variable at the exact same microsecond? Host: Alex Chan Oh, I know them. They’re the reason I have gray hair. Guest: Jordan Miller Exactly! Data races. Well, Swift 6 basically says: "I will not let you compile this code if there is even a *possibility* of a data race." It moves the check from "runtime" (where it crashes on your user) to "compile-time" (where it yells at the developer). Host: Alex Chan That sounds like a dream, but I’ve heard the migration is... let's say, "spicy." What was your experience turning on that Swift 6 language mode for the first time? Guest: Jordan Miller (Groans) Oh, boy. It was a sea of red. I turned it on for a medium-sized project, and I think I had about 200 errors immediately. It can be really discouraging at first. You’re looking at code that has worked perfectly for years, and the compiler is suddenly telling you, "This is unsafe! This isn't Sendable! You're accessing this on the wrong actor!" Host: Alex Chan Ouch. So, how do you handle that? Is it just a matter of fixing 200 errors one by one? Guest: Jordan Miller It’s more about understanding the "why." I had this "aha moment" when I was fixing a background image processing task. I realized I was passing a class—a reference type—into a background thread. In Swift 5, that was fine... until it wasn't. In Swift 6, I had to make it a `struct` or make it `Sendable`. It forces you to actually architect your data flow properly. It’s painful, but once you fix it, you have this incredible peace of mind. You *know* your app won't crash because of a threading issue. Host: Alex Chan It’s like the compiler is finally your best friend who is also a total perfectionist. It’s annoying, but you know they’re right. Guest: Jordan Miller Precisely. And the cool thing is, Apple Intelligence and Swift 6 are actually linked. Think about it: if Siri is reaching into your app via an Intent to perform an action while the user is also doing something else, your concurrency game has to be *flawless*. If your App Intent code isn't thread-safe, the whole AI experience falls apart. Host: Alex Chan I hadn't even thought about that! The complexity of the OS interacting with your app in the background makes data safety even more critical. Guest: Jordan Miller Totally. It’s all one big ecosystem now. Host: Alex Chan So, if you’re a dev listening to this and feeling a bit overwhelmed—maybe they haven’t touched App Intents and they’re terrified of Swift 6—where should they start? What’s the "Day 1" plan? Guest: Jordan Miller Don't panic! First, don't flip the Swift 6 switch on your main branch immediately. Use the Swift 5.10 "Strict Concurrency" warnings first. Fix the warnings gradually. It’s much less stressful than dealing with 200 hard errors. And for Apple Intelligence? Start by auditing your app. Ask yourself: "What are the three most common things people do in my app?" and build App Intents for those three things first. Get the "Siri-ability" working, and the rest will follow. Host: Alex Chan That’s great advice. Small steps. I think I’m actually excited to go back and look at some of my older projects now... though I might keep the Swift 6 mode off for just a *little* bit longer. Guest: Jordan Miller (Laughs) No judgment here, Alex. We all need a little time to grieve our old, unsafe code. Host: Alex Chan Jordan, thank you so much for joining us. This has been such a clear breakdown of what could have been a very confusing topic. Guest: Jordan Miller Anytime! Thanks for having me. Host: Alex Chan And thank YOU for tuning into Allur. The main takeaways today: if you want your app to survive the AI wave, get friendly with App Intents. And if you want your app to be rock-solid, start embracing the Swift 6 concurrency model—one warning at a time. For more show notes and links to the WWDC sessions Jordan mentioned, head over to our website. I’m Alex Chan, and we’ll catch you in the next episode. Happy coding!