Blog
Thoughts on software development, mobile apps, and building products and sometimes nothing in particular at all
Search & Filter with Debouncing
Searching without debouncing fires API calls on every keystroke. Here's how to implement efficient search with task cancellation.
Displaying Relative Dates
SwiftUI makes relative date formatting effortless. Show "2 minutes ago" instead of timestamps with a single modifier.
Pull-to-Refresh with .refreshable
The .refreshable modifier adds native pull-to-refresh with minimal code. Here's how to implement it with async/await and last-refresh timestamps.
ContentUnavailableView for Empty States
iOS 17 introduced ContentUnavailableView for showing empty states, errors, and search results. Here's how to use it effectively.
Building Robust Lists: Loading & Error States
Every list needs to handle loading, success, empty, and error states. Here's the pattern that covers all four with clean, maintainable code.
Modern SwiftUI Patterns
SwiftUI has matured significantly. Here's what modern SwiftUI code looks like and the patterns we'll cover in this series.
Actor Isolation in Unit Tests
Actors provide data isolation, but testing them requires understanding how actor isolation affects your test code. Here's the pattern.
Cache Behavior Testing
Caching adds complexity to async code. Here's how to test cache hits, misses, and expiration with injectable TTLs and deterministic timing.
Testing TaskGroup Operations
TaskGroup lets you run multiple async operations concurrently. Here's how to test result ordering, partial failures, and concurrent execution.
Testing Async/Await Methods
XCTest fully supports async/await. Here's how to write clean, reliable tests for your async code with mock services and error propagation.
Building Testable Service Layers
A service layer coordinates multiple dependencies. Here's how to design one that's easy to test with injected payment, email, and notification services.
Verifying Interactions with Spy Mocks
Your test passes, but did the right methods get called with the right arguments? Spy mocks let you verify interactions, not just outcomes.
Mock vs Stub vs Fake vs Spy
You've heard these terms thrown around. Here's what they actually mean, when to use each, and practical examples for iOS testing.
Repository Pattern for Testable ViewModels
The Repository pattern separates data fetching from your ViewModel, making both easier to test and maintain.
Testing ViewModels with @Published
Your ViewModel fetches data directly from URLSession. You can't test loading states, error handling, or verify the right endpoints are called.
In-Memory File Systems for Tests
Build the in-memory file system that makes your cache tests fast and deterministic. No disk I/O, no cleanup, instant operations.
Abstracting File System Access
Your image cache writes to disk. Tests create real files, run slowly, and leave artifacts behind. Abstract FileManager with a protocol.
InMemoryKeyValueStore Pattern
An in-memory store gives you complete isolation between tests—no cleanup required. Build the mock that makes UserDefaults testing deterministic.
Why UserDefaults.standard Breaks Your Tests
Your test suite passes. Then you run it again. Now it fails because the previous run left data behind. Abstract storage with a protocol.
DateProviding: Control Time in Tests
Build the mock that makes time-based tests deterministic. Test subscription expiration, 7-day reminders, and any time-dependent logic reliably.
Testing Time-Dependent Code
Your subscription check passes today. Tomorrow it fails. Tests using Date() directly are inherently flaky—inject time as a dependency.
Building Mock HTTP Clients
You've got the HTTPClient protocol. Now build the mock that makes your network tests fast, deterministic, and reliable.
Decoupling Network Code
Your tests make real HTTP calls. They're slow and flaky. Extract URLSession's interface into a protocol for fast, deterministic testing.
Protocol-Based Dependency Injection
Instead of depending on concrete types, depend on protocols that describe capabilities. Design focused protocols and injection patterns for testable code.
Refactoring Singletons for Testability
AnalyticsService.shared. AuthManager.shared. Every singleton call is a hidden dependency. Extract, conform, inject, mock—the four-step pattern.
Why Testable Code Matters
If code is hard to test, it's often because of design problems. Hidden dependencies, tight coupling, and side effects kill testability.
Managing Multiple Subscriptions
One cancellable slot, multiple subscriptions? Only the last one completes. Learn Set, Dictionary, and UUID patterns for tracking Combine subscriptions.
The Missing Cancellable Problem
Your Combine subscription vanished before receiving anything. Learn why AnyCancellable must be stored and patterns for managing multiple subscriptions.
Timer Subscriptions and Memory
Timer publishers never complete on their own. Learn why they're especially prone to retain cycles and how to manage their lifecycle properly.
![Blog post: Combine Retain Cycles: [weak self] Matters](/blogposts/27/thumbnail.jpg)
Combine Retain Cycles: [weak self] Matters
Your object never deallocates. The deinit never prints. A strong self capture in your Combine sink created a retain cycle.
Structured vs Unstructured Concurrency
Task vs async let vs TaskGroup. When to use each, their trade-offs, and why structured concurrency should be your default choice.
Unstructured Task Leaks
You tap Cancel but the task keeps running. Your polling service outlives the view. Learn to track and cancel unstructured tasks properly.
Safe Financial Systems with Actors
Building actor-based systems that correctly handle reentrancy. Patterns for transactions, reservations, and rollbacks.
Actor Reentrancy: State Changes During Await
Actors protect against data races, but not against time. How state can change across await points and why your balance went negative.
Building Responsive Search with Debouncing
Stop firing API calls on every keystroke. Implement debounced search with proper task cancellation to prevent race conditions.
Task Cancellation: The Cooperative Contract
You call task.cancel() but nothing happens. Swift's cancellation is cooperative—your code must check and respond.
Lock Ordering and Circular Dependencies
Two locks, two threads, wrong order. How circular dependencies cause deadlocks and patterns to prevent them.
Deadlocks: Sync to Same Queue
Your app freezes with no crash log. Learn to identify and fix the two most common deadlock patterns: queue reentry and lock ordering.
DispatchQueue.main vs @MainActor
When to use the classic GCD approach versus Swift's @MainActor annotation. Trade-offs, mixing them, and common gotchas.
Main Thread Violations: The Silent Crasher
That purple Xcode warning about publishing changes from background threads? Here's why it matters and how to fix it.
Thread-Safe Collections in Swift
Swift's Dictionary and Array aren't thread-safe. Here's how to wrap them with serial queues, concurrent queues with barriers, or actors.
Race Conditions: When Threads Collide
A shopping cart that loses items. Why unsynchronized access to shared state causes unpredictable bugs and how to fix them with serial queues.
Concurrency Bugs Every iOS Dev Should Know
Kicking off a series on iOS interview prep with a look at concurrency bugs, testing patterns, and SwiftUI—plus practice projects to sharpen your skills.
Practice Projects & Setup Guide
How to set up and explore the iOS-Practice projects. Project structure, running tests, and suggested learning order.
Cold Starts Improved 15x When I Re-Wrote My Lambda in Go
How I cut my iOS app's splash screen time by rewriting critical Lambda functions from TypeScript to Go—and the architectural patterns that made it possible.
Mastering SF Symbols Rendering Modes in SwiftUI
Discover the three powerful SF Symbols rendering modes—multicolor, palette, and monochrome—and learn when to use each for beautiful, colorful icons.
Don't Get Stuck at the Border This Thanksgiving: A Planning Guide
Avoid holiday border chaos with Border Notices, community-verified crossing times, and smart planning tips for Thanksgiving week.
Create a Pulsing "Live" Indicator in SwiftUI
A simple, reusable animation for real-time status indicators. Perfect for showing live data updates without being distracting.
Why Your 40th App is the One That Finally Prints
After 2.5 months building Border Times, I'm starting to understand why it takes dozens of attempts to find success. It's not about luck—it's about mastering five different disciplines at once.
Border Times iOS App Now Available
We built an app because waiting at the border really sucks. Download Border Times on iOS and join thousands of border crossers saving time and sanity.
They say the best business ideas start with solving a personal problem!
From border crossing frustrations to launching border-times.com - how personal problems become business solutions.
Protection from advertisements
The internet feels like an advertising scheme.
Status Tracker
In part two we cover updating the status tracker to have updatable state. We also swap out the titles to have a description of a state, rather than the progress state.
Status Tracker
Make a customizable status tracker with SwiftUI.
How close is AI to replacing your job?
Is llama3.1 ready for your job?
Markdown files with AWS
How to avoid .md files not being served.
Collapsable Indicator
Build a collapsable indicator in pure SwiftUI.
Let's work together
Professional discovery, design, and complete technical coverage for your ideas