Artem Mirzabekian iOS Articles & Videos

The article explains how Swift's reference counting has evolved. It starts with the early design where objects stored strong and weak counts inline, creating "zombie objects" that remained allocated until all weak references were accessed. It then covers why this changed (memory overhead, concurrency concerns) and the modern side table design where weak references trigger allocation of an external structure. The article explains inline counts, the transition to side tables, how weak and unowned work today (including why unowned crashes), unowned(unsafe), and performance trade-offs between strong, weak, and unowned.

The article explains the motivation and mental model behind Swift Concurrency, starting from the 2017 Concurrency Manifesto. It covers isolation domains (MainActor, custom actors, nonisolated), how isolation propagates through calls and closures, Sendable for safe data crossing, and common problem areas like mixed isolation, detached tasks, MainActor.run, and unstructured concurrency. It also explains actors under the hood (executors, job queues, thread independence), global actors, and the recent shift toward approachable concurrency where async code stays in the caller's isolation domain by default.

The article compares three approaches to thread safety in Swift: actors (language level isolation with compiler enforcement), DispatchQueue (execution level coordination with serial or concurrent queues), and locks (critical section level control). It explains how each works under the hood, including actor reentrancy, queue deadlocks, lock recursion problems, and the new Mutex type from the Synchronization framework. It also covers atomics for simple operations and provides practical guidance on choosing based on safety, performance, API shape, and cognitive load.