Swift

In modern iOS applications, data is constantly changing. A user logs in, a network request finishes, or a background sync completes. When these events happen, multiple parts of your application—like the UI, analytics trackers, and local databases—need to react immediately. If the object responsible for the data explicitly tells every other object to update, your app becomes a tightly coupled, unmaintainable mess. This is exactly what the Observer design pattern prevents. It defines a one-to-many subscription mechanism so that when one object changes state, all its dependents are notified automatically, without the objects needing to know about each other. ...

With the introduction of Structured Concurrency and Actors, Apple fundamentally changed how we write asynchronous Swift code. However, simply using async/await or Task does not automatically make your code safe from data races. To achieve true thread safety—and to compile under Swift 6’s Strict Concurrency checks—you must understand concurrency domains and the Sendable protocol. In this post, we will explore what Sendable is, when and how to use it, and the dangerous anti-patterns you must avoid when trying to quiet the compiler. ...

When building applications in Swift, you constantly need to compare objects, sort arrays, or store unique items in a Set or Dictionary. To do this efficiently, Swift relies on three fundamental protocols: Equatable, Comparable, and Hashable. While these protocols are easy to adopt, their behavior differs significantly depending on whether you are using a struct or a class. Let’s break down why we need them and how to implement them correctly. ...

Swift is fundamentally designed to be a safe language, and one of its core safety features is how it handles the absence of values. In many languages, trying to access a null value leads to unexpected crashes. Swift solves this elegantly using Optionals. However, the differences between normal variables, Optionals (?), and Implicitly Unwrapped Optionals (!) often trip developers up. Let’s break down how they work, the dangers of misusing them, and even look under the hood by building our own Optional type from scratch. ...

If you have ever written a single line of SwiftUI, you have seen this code: var body: some View { Text("Hello, World!") } That tiny word—some—represents one of the most powerful and complex features introduced in modern Swift: Opaque Return Types. But what exactly does some do? Why can’t we just return View? And when should you use opaque types in your own non-UI Swift code? Let’s break down the what, why, where, and the common violations. ...

With the introduction of Swift Concurrency, Actors became the ultimate tool for protecting shared mutable state. By isolating their state and ensuring that only one task can access that state at a time, actors eliminate traditional data races. However, they introduce a new, subtle, and incredibly dangerous concept that trips up even experienced developers: Actor Reentrancy. If you assume that an actor behaves exactly like a serial DispatchQueue or an NSLock, you are going to write buggy code. Let’s explore what actor reentrancy is, why it breaks your logic, and how to fix it using a real-world banking scenario. ...