# dispatchqueue Published articles for dispatchqueue. This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## @MainActor in Swift explained with code examples DevFeed: [@MainActor in Swift explained with code examples]() Original publisher: [Read original article]() Author: Antoine van der Lee Published: 2026-08-02T12:04:47Z Content type: tutorial Language: en Sources: [SwiftLee]() Topics: [Swift](), [Concurrency](), [Code](), [Xcode]() Tags: [article](), [code](), [concurrency](), [dispatchqueue](), [examples](), [guide](), [how-to](), [main-thread](), [swift](), [thread](), [xcode]() ### AI overview This tutorial explains how Swift's @MainActor global actor ensures that properties, methods, instances, and closures execute on the main thread. It also covers compiler-enforced main-thread execution, global actor isolation, nonisolated methods, and changes to default actor isolation in Swift 6.2 and Xcode 26. ### Source excerpt @MainActor is a global actor that performs its tasks on the main thread. You can use it to dispatch to the main thread by marking properties, methods, instances, or closures with the attribute. Instead of manually dispatching using DispatchQueue.main.async, you let the compiler enforce main thread execution for you. If you're new to Actors in ... -> The post @MainActor in Swift explained with code examples appeared first on SwiftLee. ## How the Swift compiler knows that DispatchQueue.main implies @MainActor DevFeed: [How the Swift compiler knows that DispatchQueue.main implies @MainActor]() Original publisher: [Read original article]() Author: Ole Begemann Published: 2024-02-29T18:54:47Z Content type: article Language: en Sources: [Ole Begemann]() Topics: [Swift](), [Compiler](), [Concurrency](), [Xcode]() Tags: [actor](), [compiler](), [concurrency](), [dispatchqueue](), [swift](), [xcode]() ### AI overview The article explains that Swift treats closures passed to exactly spelled DispatchQueue.main.async calls as @MainActor-isolated. It reports that this behavior comes from a coarse syntax-based check in the compiler's semantic analysis rather than an annotation on the method, and notes that equivalent expressions using aliases or variables do not receive the same inference. ### Source excerpt You may have noticed that the Swift compiler automatically treats the closure of a DispatchQueue.main.async call as @MainActor. In other words, we can call a main-actor-isolated function in the closure: import Dispatch @MainActor func mainActorFunc() { } DispatchQueue.main.async { // The compiler lets us call this because // it knows we're on the main actor. mainActorFunc() } This behavior is welcome and very convenient, but it bugs me that it's so hidden. As far as I know it isn't documented, and neither Xcode nor any other editor/IDE I've used do a good job of showing me the actor context a function or closure will run in, even though the compiler has this information. I've written about a similar case before in Where View.task gets its main-actor isolation from, where Swift/Xcode hide essential information from the programmer by not showing certain attributes in declarations or the documentation. It's a syntax check So how is the magic behavior for DispatchQueue.main.async implemented? It can't be an attribute or other annotation on the closure parameter of the DispatchQueue.async method because the actual queue instance isn't known at that point. A bit of experimentation reveals that it is in fact a relatively coarse source-code-based check that singles out invocations on DispatchQueue.main, in exactly that spelling. For example, the following variations do produce warnings/errors (in Swift 5.10/6.0, respectively), even though they are just as safe as the previous code snippet. This is because we aren't using the "correct" DispatchQueue.main.async spelling: let queue = DispatchQueue.main queue.async { // Error: Call to main actor-isolated global function // 'mainActorFunc()' in a synchronous nonisolated context mainActorFunc() // ❌ } typealias DP = DispatchQueue DP.main.async { // Error: Call to main actor-isolated global function // 'mainActorFunc()' in a synchronous nonisolated context mainActorFunc() // ❌ } I found the place in the Swift compiler source code ## Perfect is the Enemy of the Good DevFeed: [Perfect is the Enemy of the Good]() Original publisher: [Read original article]() Author: Keegan Rush Published: 2018-11-13T00:00:00Z Content type: opinion Language: en Sources: [The Coded Self]() Topics: [Development](), [Programming](), [Concurrency](), [reactive](), [Dependency injection](), [Mocking](), [App]() Tags: [architecture](), [architecture-pattern](), [async](), [concurrency](), [dependency-injection](), [development](), [dispatchqueue](), [mocking](), [programming](), [queue](), [reactive](), [reactive-programming]() ### AI overview The author reflects on a side project whose elaborate architecture and extensive tooling created hidden complexity, debugging difficulties, and development friction. The article examines the use of RxSwift, VIPER, Swinject, Cuckoo, and Flow Operations in an app and argues that architectural perfection can undermine practical progress. ### Source excerpt How the Wrong Architecture Can Cripple Development A couple of years ago, I was working on a side project with a few friends. We thought that it would be the next big thing. We put our collective best efforts into it; I worked long, hard hours fleshing out the scaffolding of the perfect architecture. Little did I know that my effort would doom the project to join the abyss of failed projects as quickly as it had begun. We had the best tools Since this was The Next Big Thing™, we used everything at our disposal. RxSwift for reactive programming VIPER for our architecture pattern Swinject for dependency injection Cuckoo for mocking Flow Operations for managing navigation The Flow Operations were a particularly interesting concept, inspired by the Advanced NSOperations session from WWDC 2015. We used Flow Operations to manage navigation in the app. For instance, if you wanted to register a new user, you'd invoke a RegisterFlowOperation. A FlowOperation was a subclass of Operation: class FlowOperation: Operation The Operation class represents the code and data for a task of your choosing. It also handles concurrency and dependencies. So, our Flow Operations represented the task of flowing from one screen to another in an app. Operations can be dependent on each other - for instance, the EditProfileFlowOperation is dependent on the SignInFlowOperation. If you've already signed in, you can edit your profile, but if you haven't, then you'll be directed to sign in if you invoke the EditProfileFlowOperation. How does it work? There was a lot of hidden complexity in the Flow Operation system, and some trickiness that you wouldn't notice until you started using it. I'll briefly go over some of the code. You could sell products in this app we were building. This is how you'd start the Sell Flow: private func startSellFlow() { DispatchQueue.global().async { [navController = navController] in let flow = SellFlowOperation(navigationController: navController) flow.beginFlow() flow.