Blog on iOS Development

A practical map from Combine to Swift async sequences: subjects to AsyncStream, sink to for await, @Published to @Observable and Observations. Plus five differences from publishers that break code if you miss them, for iOS 17 and iOS 26 targets.

A flaky test traced to two Swift Testing suites drawing into the same UIWindow, because suites run in parallel and every await yields the main actor. The fix is a suite-scoped async lock implemented as a TestScoping trait.

`some` and `any` are two keywords that look almost identical but represent opposite guarantees. This post explains opaque and existential types, how they're implemented, when to use each, and what they mean for performance.

associatedtype lets protocols define behaviour without committing to a concrete type. This post covers what it is, why it exists, how SwiftUI is built on top of it, and what it means for your architecture.

Swift Package Registry promises faster builds and tighter supply-chain control — but the tooling has rough edges. Here's how it actually works, and where to watch out.

Part 2 of the iOS secrets series. A step-by-step walkthrough of how an attacker extracts secrets from a real iOS binary — FairPlay decryption, static analysis, Frida injection, memory scanning, and where Apple's defences get addressed along the way.

Every secret you ship inside an iOS app is physically on a device you don't control. This post covers what counts as a "secret", the full threat model for leaks, and where Apple's built-in protections actually stop.

Swift implements four types of method dispatch: inlining, static, table, and message. Understanding which one applies and when explains some of Swift's most confusing behaviour — and helps you write faster code.

Practical refactoring tips for migrating to Swift 6 concurrency: @Sendable, sending, region-based isolation, and common error fixes.

A guide to region-based isolation, @Sendable, sending and unchecked sendable, and closure safety in Swift 6 with examples.

A deep dive into Swift's concurrency model, focusing on actors and region-based isolation.

A detailed guide to Swift structs vs classes: value vs reference semantics, inheritance, memory, closures, and interview insights.

Save time and increase accuracy when releasing a build.