Swift's lazy var Looks Like Free Optimization. It's Also a Free Data Race.
lazy var defers a property's initialization until first access — but Swift never promised that first access is safe from two threads at once. Here's what actually happens when it isn't, and how to fix it without giving up the laziness.
Every Swift Task Already Has an ID. You Just Couldn't Read It Cheaply.
SE-0553 adds Task.currentID to Swift — a process-unique, never-reused task identifier that costs nanoseconds instead of the 15x-slower withUnsafeCurrentTask dance. Here's why that gap existed and what it unlocks for tracing and logging.
Your Pull-to-Refresh Spinner Vanishes Instantly. Your .refreshable Closure Isn't Actually Async.
SwiftUI's .refreshable modifier hides its spinner the moment your closure returns — not when your data arrives. Here's the fire-and-forget Task bug that causes it, and the fix.
Thread Sanitizer Just Flagged Your Correct Code as a Race. Swift Might Finally Let You Say 'I Know.'
SE-0550 proposes a @noSanitize attribute for Swift functions, letting you opt individual functions out of ASan/TSan instrumentation. Here's the real problem it solves, and the sharp edges it comes with.
Swift's let Never Meant 'Never Changes.' A New Pitch Wants Property Wrappers to Admit It.
A fresh Swift Evolution pitch lets property wrappers live on let declarations, fixing the real Swift 6 strict concurrency error that rejects thread-safe wrappers in Sendable types, static properties, and nonisolated members.
Date() Subtraction Lies to You About Elapsed Time. Swift's ContinuousClock Doesn't.
Measuring elapsed time with Date() subtraction quietly breaks when the system clock changes mid-measurement. Swift's ContinuousClock and Duration fix it — here's the difference and when it actually matters.
Swift 6.4 Lets Your defer Block Await. withTaskCancellationShield Is Why That's Actually Safe.
Swift 6.4 ships async defer (SE-0493) and withTaskCancellationShield (SE-0504) together, finally letting cleanup code make network calls without racing cancellation. Here's what changes and why the pairing matters.
Your defer Didn't Fire Late. It Fired Exactly on Time — Just Not the Time You Meant
Swift's defer runs at the end of the enclosing scope, not the end of the function. Inside an if/else branch, that difference can silently defeat the cleanup you thought you wrote.
Migrating a Real App to Swift 6.2 Strict Concurrency: 86 Errors, One Afternoon, One Race Condition I Didn't Know I Had
I migrated Invoize from Swift 6.0 strict mode to Swift 6.2 approachable concurrency on a Sunday afternoon. Every warning, every fix, the one real race condition the compiler finally surfaced — and the TDD seams I leaned on so the migration wasn't just compiler-driven guessing.
@concurrent vs nonisolated vs @MainActor: The Swift 6.2 Decision Tree That Fits on a Napkin
Four real scenarios — UI update, network call, image decode, file IO — and exactly which Swift 6.2 isolation keyword each one needs. A TDD walk-through with Swift Testing, no whiteboard ceremony required.
MainActor by Default: Why Apple Just Reversed Swift's Concurrency Story
Xcode 26 flips the default — your code now runs on the main actor unless you say otherwise. Here's why Apple changed direction, what it actually means for your existing project, and a TDD walk-through showing the migration in real Swift.
Swift 6.2 Finally Made Concurrency Approachable — Someone Already Built a Parody Site
Swift 6.2 ships @MainActor by default, the new @concurrent attribute, and a complete rethink of strict concurrency. We break down what changed, show real migration code, and explain why the community is both celebrating and arguing.