Curated topic · 73 ARTICLES
Explore practical Swift articles grounded in clear explanations and engineering tradeoffs.
Latest articles
App sizes shrank after Swift 5 and iOS 12.2 shipped in 2019, thanks to ABI stability. This article covers how the Swift runtime moved from every app into the OS, along with module stability and the trade-offs of @frozen.
Read articleResources such as file handles and locks are meaningful only when unique, so they must not be copied. This guide explains how Swift 5.9’s ~Copyable encodes noncopyability in a type, covers borrowing, consuming, and inout, and clarifies where to use them.
Read articleSwift 5.9 macros are code-generation plugins embedded in the compiler. This overview covers how they receive syntax trees and return code, the freestanding (#) and attached (@) branches, and the cost of creating your own.
Read articleA struct's size is not a simple sum of its properties. This covers measured size, stride, alignment, padding, Optional's use of extra inhabitants, and 64-bit existential containers.
Read articleMethod calls compile as direct calls, vtable lookups, or objc_msgSend. This article explains why final and private improve performance, the trap in protocol extensions, and how to verify it with a profiler.
Read articleStructured concurrency answers who is responsible for ending asynchronous work. This article covers why child tasks cannot escape their parent scope, how cancellation propagates, and which guarantees you must manually reclaim with Task.detached.
Read articleTurning on Swift 6 mode unleashes concurrency errors, with Sendable at the center. This guide explains whether values may cross isolation boundaries and presents migration fixes in order: make them structs, make them immutable, or promote them to actors.
Read articleDelegates and closures handle the same callback needs, but they have different trade-offs. This article implements the same example side by side, distills five practical differences, and summarizes how to choose based on event count, relationship lifetime, and whether a return value is needed.
Read articleAn actor is Swift’s fourth kind of type, protecting its own state. This guide explains how serialized access lets the compiler catch data races, including the classic reentrancy trap.
Read articleAt await, the function—not the thread—pauses. Here’s what suspension really means: the function stores its state on the heap and returns the thread to the cooperative pool, and why sequential await is not parallel execution.
Read articleFactory is a Swift DI library that catches missing dependency registrations at compile time. As of July 2026, this guide covers version 3.3.1, basic usage, scope declarations, test and preview injection, and differences from Swinject.
Read articleProtocol-oriented programming (POP) designs types around what they can do, not what they inherit. This article covers where inheritance falls short, how to solve it by composing protocols, and when to avoid it, with Swift examples.
Read article\.name is not shorthand syntax for map, but a value of the independent KeyPath type. This article explains what it means to turn property access into a value, the three layers—read-only, value-type writable, and reference-type writable—and practical use cases.
Read articleProperty wrappers are a Swift language feature introduced in Swift 5.1 through SE-0258, not SwiftUI syntax. This article explains how the compiler translates @Clamped, what wrappedValue and projectedValue ($) really are, and where to draw the line against overuse.
Read articleFrom what Codable synthesis actually generates to standard fixes for key mismatches, date formats, nested structures, and partial failures—and DecodingError debugging.
Read articleThe five functions map·filter·compactMap·flatMap·reduce differ by what the closure returns. This guide covers when to choose them over for loops, the intermediate arrays created by chaining, and the problems lazy sequences solve.
Read articleIn Swift 5.5 and later, declare test functions as async, await the result, and then verify it. This guide also covers error validation, testing legacy callback APIs, and when expectations are still needed.
Read articleAssociated types are type placeholders built into protocols. This article explains the infamous generic constraint error, how SE-0309 and SE-0346 removed the restrictions, and how to use primary associated types.
Read articleIn code written since Swift 5.6, you’ll see some or any before protocol names: some View, any Error, some Collection. Protocol names used to work directly in type positions, but the compiler now warns or errors unless you add any.…
Read articleWhen writing test code for iOS development, XCTest can start to feel restrictive.
Read articleYou’ve probably heard someone say in a code review, “Please add final to this class.”
Read articleThe first time you encounter angle brackets <T> in Swift code, you pause. A capital letter appears beside a function name, and opening the documentation reveals signatures like func map<T>( transform: (Element) -> T) -> [T]. Generics are the gateway to intermediate Swift…
Read articleIn the closures article, when we covered breaking retain cycles with [weak self], we left one question open. There is also unowned instead of weak—what is the difference, and when should you use it? To answer, we first need to look beneath the surface at how ARC actually works.
Read articleAs your iOS app grows, dependency management can become a real headache.
Read articleSE-0296 and SE-0345 often appear in Swift articles and release notes. SE-0296 accompanies async/await, while SE-0345 appears in discussions of shorthand if let name syntax. What are these numbers?
Read articleThe Swift standard library reveals one striking fact: not only primitive types such as Int, Double, and Bool, but also String, Array, Dictionary, and Set are all structs. Things that are naturally classes in other languages are value types in Swift…
Read articleSwift has an unusual coexistence: beginners start with one line, print("Hello"), in Playgrounds, while the same language implements a standard library tangled with generics and macros. A coding education app for elementary students (Swift…
Read articleWhen you build a screen that spawns lots of game effects, frames can suddenly start stuttering.
Read articleWhen building an iOS app, you eventually encounter it: one screen mixing loading, success, failure, and empty-data states.
Read articleWhen studying OOP, you hear “encapsulation” countless times, but when someone asks, “So how do you do it in code?”, you can suddenly go blank. You understand the concept, but your hands do not know what to write.
Read articleSwift Copy-on-Write shares storage when value types are assigned and performs an actual copy only when one side is modified. This explains how the optimization preserves value semantics while reducing the role of the Prototype pattern.
Read articleWhen building a network layer, you inevitably hit moments like this.
Read articleWhen writing Swift, you eventually wonder: Why are optionals so strict? Why are arrays copied? Why does guard exist? Digging into these questions leads to Swift’s three original goals: Safe, Fast, and Expressive.
Read articleSwift static factory methods express creation intent through names and control return types, caching, and instance reuse. This summary covers the trade-offs of choosing static func make over init and how it differs from the GoF pattern.
Read articleDid you have this thought when you first saw SwiftUI?
Read articleWhen building an iOS app, you eventually hit a familiar roadblock.
Read articleWhen building an iOS app, view controllers can gradually become bloated.
Read article"Why do we still use @autoreleasepool in the ARC era?"
Read articleThe Interpreter Pattern always appears near the end of design pattern books. It is easy to skip because you wonder, “When would I ever use this?”
Read articleIn iOS development, you eventually need to keep adding operations to objects of many kinds, such as shapes or nodes.
Read articleHave you ever copied similar logic across classes and thought, “This feels wrong”? By the third copy of screen-specific data-loading code in an iOS app, your hands start to hesitate.
Read articleWhy Swift String rejects integer indices, starting with extended grapheme clusters. Verify Character, Unicode scalar, and UTF-8 differences in composed Hangul by running code.
Read articleHave you ever hit a wall while adding an “Undo” button to an iOS app?
Read articleIf you've grown an iOS app beyond the basics, you've probably encountered this moment.
Read articleiOS development has a point that often causes confusion.
Read articleWhen building apps with Swift, you write loops like for item in array dozens of times a day. Because they feel so natural, you may only start wondering how they work after a custom type fails to compile in a for-in loop: "What is actually happening inside this loop?"
Read articleThe Facade pattern provides a single, simple entry point to a subsystem involving multiple objects. Using a Swift sign-up example, this article explains how to centralize call order and how Facade differs from Adapter, Proxy, and Decorator.
Read articleWhen building an iOS app with Swift, you may have wondered why this view controller receives an event after you tap a button.
Read articleThe State Pattern groups state-specific behavior and transitions into objects or enums, reducing scattered conditionals. This article explains how to refactor Swift screen states and distinguish intentional designs that resemble the Strategy Pattern.
Read articleSwift guard handles failure conditions first and keeps the happy path flat. Verify its compiler guarantees over if, optional-binding scope, and when to choose return, throw, or continue with runnable examples.
Read articleWhen building an app, you may need to create thousands or tens of thousands of similar objects. A typical example is placing tens of thousands of markers on a map, where the memory graph can easily keep climbing.
Read articleSwift error-handling tools differ by when failures are handled and what information must be preserved. We compare throws, do-catch, try?, try!, and Result alongside their runtime behavior.
Read articleWhen building an app, requests to “just add an undo button” come up more often than you might expect.
Read articleThis is part 3 of the Swift basics series. It organizes five property types around selection criteria rather than syntax lists. The key question is simple: is this value stored, computed, and when is it created?
Read articleWhen building an app with Swift, you eventually reach a point where classes keep multiplying.
Read articleWhen developing for iOS, you end up using lazy var very often.
Read articleWhen developing iOS apps, you sometimes want to add just logging or caching while keeping the core behavior intact. Start subclassing for that, and before long the inheritance tree becomes a mess.
Read articleA folder inside a folder, with more files inside. If you’ve handled this kind of tree structure in code, you’ve probably felt stuck at least once.
Read articleThe Prototype pattern reduces creation costs and duplicated setup by cloning existing objects. This article summarizes how Swift value-type copying differs from NSCopying in classes, and where shallow copying and Copy-on-Write come into play.
Read articleThe first hurdle when learning Swift is optionals. The question mark in String?, if let, guard let, !, and ??. With so many forms of syntax, memorizing each separately can easily turn the rules into a jumble.
Read articleWhen building an app with Swift, your initialization code eventually starts looking like this.
Read articleAbstract Factory groups mutually compatible objects into product families and replaces them at once. Using a Swift theme example, this article explains how to prevent composition errors and choose between it and Factory Method.
Read articleSwift factory functions give creation logic intent-revealing names and make return types and reuse policies flexible. This covers when to choose static func over init and how it differs from the GoF Factory Method.
Read articleClosures are everywhere in Swift code. But many developers still struggle to explain exactly what capture means, why [weak self] is used, and why @escaping is needed.
Read articleThe Adapter pattern converts a legacy API's interface into a protocol expected by new code. This guide covers how to create a conversion boundary in Swift, simplify replacement and testing, and distinguish it from other wrapping patterns.
Read articleiOS developers encounter the delegate pattern constantly.
Read articleWhen building an iOS app, you inevitably hit situations like this: something changes on screen A, and a distant screen B also needs to update.
Read articleHave you ever dealt with code where if-else branches kept multiplying for each payment method?
Read articleWhen developing with Swift, you eventually encounter a moment that makes you pause.
Read articleWhen developing with Swift, you encounter singletons created with a single line, static let shared, very often.
Read articleAnyone starting iOS development has wondered at least once: "Why did Apple create Swift from scratch instead of sticking with the Objective-C it was already using?"
Read articleFor anyone who has wondered whether using a Singleton really is okay
Read articleWhen building an app with Swift, you may have caught an error with do-catch, only to find that the message displayed on screen was less than helpful.
Read article