I'm an iOS Engineer working in London startups. Every 2 weeks, I'll send you ludicrously in-depth articles about iOS, Swift, tech, & indie projects. My primary niche is mobile engineering, but there’s something for everyone in my repertoire: including CPU architecture, job interviews, accessibility, compilers, hacking, startup fundraising, and memes.
Build a Photos-like face grouping pipeline on iOS: use Vision’s VNDetectFaceRectanglesRequest to find faces, discard tiny/low‑confidence hits, convert crops into 512‑D embeddings, then cluster to identify people—all on-device. Includes a sample project and optimization notes.
Cloning Photos, a UICollectionView grid collapses at 31 columns: layoutSubviews, cellForItemAt, and PHImageManager dominate the main thread, causing hitches. The fix: keep UIKit’s scroll physics but render with Metal on the GPU to target 120fps. Use Instruments to verify.
Why iOS 27 apps launch ~30% faster and how to profile yours. Explains cold vs warm launches and pre‑main steps (dyld closures, mapping images, fixups). Shows Instruments’ App Launch and Xcode 27 flamegraph; warns too many dynamic frameworks slow startup.
Apple’s WWDC 2026 reads like a Snow Leopard year: fewer flashy UI changes, more stability and dev-focused AI tools. To tame the video deluge, the author auto-summarized all sessions with Granola and shares a browsable roundup, plus polls for deep dives (App Intents, SwiftUI, Apple Intelligence, performance).
Historical tour of Apple CPUs (6502→68k→PowerPC→x86→Apple Silicon, 1977–2026) teaching CPU and performance basics: registers, ALU, CISC vs RISC, pipelining, caches, branch prediction, UMA, OOO. Frames each era with business context and Apple’s tight HW/SW integration.
Case study: migrating a SwiftUI app to a UIKit navigation skeleton for performance and flexibility. Keep SwiftUI screens, move routing to UIKit; use @Observable (iOS 18+), UIPresentationController, and a custom tab-bar “meeting bar”. Fixes scroll/keyboard jank; agentic tools verify work.
Explains reliable data uploads on iOS: start with URLSession fire‑and‑forget, then add retry discipline—user retry, automated retries with exponential backoff + jitter, circuit breaker, Retry‑After handling, and idempotency keys. Choose reliability level per feature.
Maps iOS’s UI pipeline: a tap goes from capacitive sensor → IOKit IOHIDEvent → backboardd/BackBoardServices → GSEvent → app run loop/UIEvent → CATransaction/layer tree → CAContext IPC → render server → GPU/vsync/display. Highlights that much is private/undocumented.
Jacob's Tech Tavern raises premium to $15/mo on May 31; current subscribers keep lower pricing. Perks: 45 paywalled articles (~98k words), early access, a Swift Concurrency course and advanced training, plus a free 'Land your iOS Tech Job' eBook. Teases a UI pipeline deep-dive.
Swift 6.2 outlines 3 tiers: 1) run everything on MainActor (single-threaded), 2) use async but stay serial on MainActor, 3) opt into off‑main parallelism with @concurrent. Also covers Xcode’s Approachable Concurrency and Default Actor Isolation, plus trade-offs.
Explains Swift 6.2 Approachable Concurrency in three tiers: 1) run everything on MainActor, 2) add async while staying single‑threaded, 3) opt into off‑main work with @concurrent. Focuses on Xcode settings (Approachable Concurrency, Default Actor Isolation) and why serial‑by‑default cuts data races.
From URLRequest to electrons: what happens after URLSessionDataTask.resume(). Covers URLSession internals (GCD, NSOperation), async/await (withCheckedThrowingContinuation), HTTP/DNS/cookies/caching, HTTP/2 multiplexing energy savings, and the kernel handoff via socket/connect/send/recv.
An iOS engineer’s multi-agent workflow: run high-thinking LLM agents for hours with verification (build, run, log, test, auto-fix). Use multiple repo checkouts and per-checkout DerivedData to avoid xcodebuild locks. Orchestrate CI (Bitrise/MCP). Core skill: latency management. Takeaway: verification + parallelism speed safer shipping.
Calls out cargo-culting in mobile teams: complexity debt crushes velocity. Don’t replace UIKit/SwiftUI with custom UI stacks (e.g., HypeUI); use UIKit when you need performance and simplify UIs. Niche frameworks trip up AI coding due to scarce training data.
Announcing a 109‑page guide to land iOS roles amid AI‑era hiring volatility. Covers technical screens, system design, and the “iOS coding” interview, distilled from 10 years’ experience and 30 interviews. Two paths: skill up and join resilient teams. Paid subs free; discounts offered.
Breaks down vague “iOS coding” rounds into 5 drillable types: screen building (SwiftUI/UIKit), component design, LeetCode‑lite DS/algos, fundamentals (concurrency/GCD, debugging, testing), and API design with protocols. Use timed drills, sample projects and AI tools to prep.
Compares two SwiftUI design system approaches: composition (idiomatic view layering) vs progressive disclosure (enum-based initializers). Author defends pragmatic approach over purely idiomatic composition. Focuses on design system implementation strategies, extensibility patterns.
A comprehensive performance comparison between SwiftUI and UIKit scroll performance in iOS 26. Tests using an extremely complex UI with high-res animated GIFs, variable cell sizes, and real-time animations to push both frameworks to their limits. Examines Apple's claims about SwiftUI performance improvements in iOS 26, using Instruments profiling and real-world metrics from apps like Ice Cubes for Mastodon to determine if SwiftUI has finally achieved parity with UIKit's scroll performance.
iOS system design interviews challenge developers to architect complex systems like messaging apps, news feeds, or SDKs. Based on three real interviews, this guide provides a structured framework: scoping, functional/non-functional requirements, data model, API design, high-level design, and drill-down questions. The article emphasizes understanding data flow over UI frameworks and includes a worked example of an AI chat app interview question with practical prep tips for iOS developers targeting high-paying tech companies.
Case study of a client-side, multi-stage ingestion pipeline: webscraping a third-party, long-running downloads, parsing/storing ~200MB+, real-time analysis, and high-volume upload with polling—hardened over a year atop leaky abstractions. Lesson: build resilient, fault-tolerant workflows.
Explores advanced agentic AI workflows for iOS development in 2026, covering the latest GPT-5.2 Codex and Opus 4.6 models with high reasoning modes. Discusses multi-agent orchestration, XcodeBuildMCP for Xcode verification, and Apple's first-party MCP support in Xcode 26.3. Details workflow optimization techniques including parallel agents and verification loops to dramatically improve productivity for iOS developers using AI coding tools.
Life update and survival guide to big‑tech interviews: from CV optimisation and recruiter screens to first tech rounds, take‑homes, panels, and offers. Includes market outlook for native iOS (AI startups hiring; fewer FAANG in London) and tactics to raise pass rates.
Use Xcode Organizer as a performance funnel: monitor its crowdsourced metrics and code-level reports to catch launch-time, scroll, termination, battery, and storage regressions. Slice by OS/device/version, then dive with Instruments to pinpoint, fix, and verify improvements.
Deep dive into RevenueCat’s iOS SDK for subscriptions: façade-first API (Purchases), an orchestrator, and service/infrastructure layers using constructor DI. Covers StoreKit purchases, backward compatibility, offline-first correctness, and perf‑aware defaults.
A candid guide claiming most LeetCode rounds boil down to ~10 patterns: hashmaps, two pointers, sliding windows, stacks/queues, binary search, trees/DFS, graphs/BFS, backtracking, sort‑and‑sweep, and DP. Emphasizes O(1) hashmap lookups and time complexity. Treat interviews as pattern drills.
Holiday update: the author is taking a two‑week break over Christmas after a busy month of interviews and family time. To thank supporters, all paid subscribers are gifted 14 days of membership access.
Explains how isKnownUniquelyReferenced() enables copy-on-write in Swift. Walks the implementation across ManagedBuffer, Builtins, compiler (AST→SIL→LLVM IR), runtime, and SwiftShims. Demonstrates a Box/Ref CoW struct, when it’s appropriate, and memory/performance trade-offs.
Deep dive into Objective-C runtime internals for modern Swift/UIKit apps. Explains messaging (objc_msgSend), method dispatch, swizzling, associated objects, introspection, message forwarding and NSProxy, with practical uses like screen/dwell-time tracking and collections—to simplify Swift code.
Deep dive into Swift method dispatch: how the compiler and runtime execute function calls, the four dispatch forms Swift uses, what optimizations they apply to your methods, when tips like final/fileprivate or co-locating generics are redundant, and how to reason for faster code.
Overview of Meta’s iOS-specific system design interview: how it differs from backend-focused design rounds, why leveling hinges on system design and behavioral interviews, and what to expect. First-hand insights to demystify the format and evaluation for iOS candidates.
Lessons from Dave Verwer on when to kill projects: quit fast when interest is low (iOS Dev Survey), do real user research (Tackle Fishing), and retire successes once obsolete (AppReviewTimes). Also covers Swift Package Index: SPM-first, open source, CI that builds packages across toolchains/platforms.
SwiftUI’s edge is fading. In 2025 Apple added @Observable and updateProperties() to UIKit (back‑deployed to iOS 18), and agentic AI slashes layout boilerplate. SwiftUI still trails in API coverage and performance (diffing/layout). Weigh migrating back to UIKit.
Hands-on Swift Concurrency kata: 12 real‑world challenges in a prebuilt “murder mystery” app. Finish features, fix bugs, and wire async flows using task groups vs async let, actors, and AsyncStream. Goal: build hard‑won intuition and production‑ready concurrency skills.
Spiky Tuist cache traffic plus a provider network fault stalled S3/DB calls, exhausting pools and crashing the server. Fixes: fail‑fast queues, tuned pool_size/queue_target, URLSession retries/timeouts, migration to Render. Takeaway: measure latency; design for failure.
Swift for Android’s early developer preview formalizes years of hacks. The author contrasts it with Kotlin Multiplatform by building twin apps: Swift for Android + Jetpack Compose vs KMP + SwiftUI, comparing developer experience for shared logic with fully native UIs.
How researchers extract internal Swift interfaces from Apple’s private frameworks. Covers where to find iOS SDK binaries, what binaries contain, and how to reverse-engineer them with MxIris’s MachOSwiftSection—including a peek at the Foundation Models framework.
100-day sprint to sustain Jacob’s iOS dev blog: grow free subscribers (War Stories, Creator Spotlights), test paid acquisition and referrals, and lift paid conversion with clearer value and future Tavern Tools for members. Target: £50k ARR.
Backend/server‑driven SwiftUI: define a minimal JSON DSL and a SwiftUI renderer to drive screen structure from the backend. Examples: static post, Netflix‑style feed via composition + navigation, and a media‑posting form. Focus on power vs simplicity—avoid re‑implementing HTML; use judiciously.
Announces a referral program: every referral grants 1 free month of paid membership ($12). 4 referrals = 3 months; 16 = a full year. Rewards stack and extend existing subscriptions automatically. Includes a referral link and notes member perks like early access and a course.
Guide to full camera control on iOS: start a simple AVCaptureSession with AVCaptureVideoPreviewLayer, then grab frames via AVCaptureVideoDataOutputSampleBufferDelegate and apply real-time processing using Metal, Vision, or Core ML to create custom effects from live pixel buffers.
Argues for playful loading screens and demonstrates building a simple 2D game engine in SwiftUI. Explains what a game engine is and its moving parts, then wires them up to ship Flappy‑style minigames in a real loading screen. Includes open‑source engine and sample app.
Explains how Swift actors work under the hood: the compiler synthesizes a serial executor and enforces async boundaries on every access. It inspects SIL to show compile-time wiring, then the runtime executor’s isolation, task switching, enqueuing, and thread-pool draining.
A solo tech cofounder reflects on shipping a gamified climate‑action app: starting with a bare‑bones MVP backend, then overengineering a “scalable” system post‑funding, and what he should’ve done instead. A cautionary lesson on right‑sizing architecture and avoiding premature complexity.
Hands-on guide to cutting iOS app launch time. Shows a real-world case and three tactics—offload work to background threads, maximize CPU at launch, and resolve dependencies smartly—plus production monitoring and pre-main tuning. Covers deadlock/race pitfalls.
Swift scripting has long been painful. This post introduces swift-subprocess—a brand‑new Swift package—for automating tasks by running system commands from Swift. It outlines why scripting hurt and how this tool helps. Takeaway for iOS devs: Swift is becoming viable for CLI automation.
Deep dive into Data's swift-foundation implementation reveals sophisticated memory optimizations. Data uses four representations (Empty, InlineData, InlineSlice, LargeSlice) based on size, avoiding heap allocation for small data via stack-based tuples. Core approach: wrap heap pointers in __DataStorage with copy-on-write semantics. Key optimization keeps enum representations ≤16 bytes to stay inline. Performance critical: heap slow, stack fast principle drives design choices throughout.
A historical tour of Apple concurrency from 1977 to today, with runnable examples: primitive scheduling on Apple ][, Macintosh multitasking, NeXTSTEP POSIX threads, OS X Grand Central Dispatch, and modern Swift Concurrency (async/await). Traces the evolution toward ergonomic parallelism.
Demonstrates building real-time iOS systems using Combine with WebSockets through three examples: connected thermostat, live auction, and gaming. Uses URLSessionWebSocketTask with Combine operators like decode, throttle, buffer, and scan. Shows PassthroughSubject for broadcasting data, type erasure with AnyPublisher, and performance optimization techniques. Includes testing strategies with mock services and SwiftUI previews. Key challenge is managing high-frequency updates and back-pressure in real-time scenarios.
Guide to building offline, client-side AI on iOS with Apple’s MobileCLIP (CLIP) Core ML models: pick/download a model, customize via Python to make text embeddings, embed in your app, and classify images using Vision. Notes B(LT) works best but ~173MB. Enables zero-shot search/categories.
Growth promo: Free subscribers can refer 1/5/20 people to earn 1/3/12 months of paid access. Paid subscribers can send gift months; share all gifts for 1 free month, and get 3 months if a gift converts to paid. Extensions are appended to billing; DM to claim.
Building a trading card app using client-side AI, combining MobileCLIP for zero-shot image classification to generate personalized stats/titles, Vision framework for foreground masking, Metal shaders for holographic effects, SwiftUI for UI, and SwiftData for persistence. Uses CLIP embeddings for deterministic stat generation from photos, applies different rarity levels, and creates shareable trading cards with custom graphics effects.
Explores Swift's lesser-known, advanced features including unowned(unsafe) references, withoutActuallyEscaping for escaping closures, dlopen() for dynamic library loading, malloc/free with withUnsafeTemporaryAllocation for manual memory management, _modify accessor for in-place mutations, and autoreleasepool for Objective-C memory management. These "forbidden" Swift features offer powerful capabilities but require careful handling due to unsafe operations and potential crashes. Most are niche tools for performance optimization or low-level system programming rather than everyday development.
Practical guide to AsyncStream/AsyncThrowingStream: build async sequences to bridge delegate/callback APIs. Examples: CoreLocation heading stream with .bufferingNewest(1), download progress via URLSessionDownloadDelegate, and CADisplayLink FPS tracking with onTermination cleanup. Use for-await-in; continuations are Sendable.
An indie founder recounts Apple trapping his app in App Review for 170 days, starving a startup at launch. He shares how they ultimately got unstuck by invoking Apple’s biggest fear, offering takeaways on navigating App Store review power dynamics as an iOS developer.
Announcement: Jacob’s Tech Tavern is raising paid subscription prices 60% on May 15, 2025. Subscribe before to lock in $7.50/month forever. New price: $12/month ($110/year). Existing subscribers keep current rates. Options: 14‑day trial, concessions, and 40% group discount/L&D template.