Blog

Parameterised tests removed a third of my test code, and one behavioural difference caught me out.

The habit that changed my rate of improvement most, and how to start without being overwhelmed.

They look like syntax and they are objects. When that matters, and when it does not.

What it genuinely fixes, what it hides, and the three places I still drop down to the layer underneath.

Three methods, one Coordinator, and the update loop that will freeze your app if you get it wrong.

A shared core in Rust with a Swift app on top: the FFI boundary, the memory rules, and whether it was worth it.

Twenty lines of async/await, plus the decision that matters more than the algorithm.

Previews stopped working in my app, so I stopped using them. Getting them back changed how I build screens.

Every one was avoidable. What the guideline number really meant, and the reply that got each build approved.

unsafe is not a way out of the borrow checker. It is a promise, and here is what writing that promise down looks like.

Two Swift features that look like the same idea. One is safe from concurrent access and the other will corrupt memory.

Four functions and about sixty lines. The API is unpleasant, and it is not big enough to justify a dependency.

I did not believe the zero-cost claim, so I looked at the assembly. Here is what the compiler actually does.

It looks like hostility to beginners. It is the only correct answer, and the reason is one emoji.

Long-form is worse for reach and better for everything else. What writing a chapter does that a thread cannot.

BGTaskScheduler is a request, not a promise. Six reasons mine never fired, and how to test one in ten seconds.

The modifier that replaced onAppear, the `id:` parameter that fixed my stale data, and the one case where it does not fire.

Your queries are verified against a real database while you build. What that catches, and what it costs your CI.

Six ways a synthesised Codable fails against a real API, and what to write instead.

Where the size actually was, and the one number Apple reports that is not the one users see.

Twelve `.shared` properties made half the app untestable. What I replaced them with, and the two I kept.

What a static Astro site with one shader and some vanilla JS costs to build and maintain, four months in.

Extractors, state, middleware and error handling — the structure I arrived at after getting the first two wrong.

Macros are the most powerful metaprogramming tool Swift has. Two of the three I wrote should have been functions.

A wall of hex addresses becomes a line number in three commands, once you have the right dSYM.

Programmatic navigation that survives a deep link, a state restore and a 'pop to root' — in about forty lines.

clap's derive API, plus the four things that separate a script from a tool people will use.

The mechanism behind @ViewBuilder, built from scratch for a query DSL — and the honest case against doing it.

Every one of these was a confident guess, and every one was wrong. What the profiler actually said.

Settings in the project file are invisible in review and a merge conflict waiting to happen. Text files fix both.

Static and dynamic dispatch in Rust, and the question that settles it faster than benchmarking does.

800 warnings on day one. The order that made it tractable, and the two changes that removed most of them.

What modularisation actually bought, what it cost, and the dependency mistake that took a week to undo.

Data flows down the SwiftUI view tree through the environment. PreferenceKey is how it flows back up.

Four things, in order. Style is not one of them, and neither is anything a linter can catch.

The `'a` in a struct definition means something specific, and it is usually a sign you should have used String instead of &str.

Cancellation in Swift concurrency is cooperative. If your code never checks, cancelling it changes nothing at all.

Measuring which functions are slow to type-check, and the three expression patterns that caused most of it.

A SwiftUI list that stuttered on an iPhone SE. None of the causes were what I assumed.

The default answer to shared state in Rust, and why reaching for it first is usually a design shortcut.

Actors prevent data races. They do not prevent your invariants breaking across an await, and I found that out in production.

Four years in, the gaps I actually had were not the ones I worried about. What I would prioritise now.

A leak that added 4MB per screen push. How to find one in five minutes instead of reading every closure in the file.

It is greedy, it runs in the sizing pass, and four newer APIs cover most of what people use it for.

async-std, smol, or tokio. The decision took me a week and should have taken ten minutes.

@unchecked Sendable silences the compiler and keeps the bug. Four ways to earn the conformance properly.

Where the time actually went in an app I was sure was already fast, and the measurement that made it visible.

A mechanical migration with one non-mechanical part, and a performance win I did not expect to be that large.

Not tips. A procedure — the one I fall back on when the bug has beaten me for a day and guessing has stopped working.

Two crates that look like alternatives and are not. The rule that decides which one, in one sentence.

The rule everyone quotes is about lifetimes. The rule that actually keeps you safe is about who outlives whom, and I learned it the expensive way.

Instruments shows you a flame graph and a million samples. The four settings that turn it into an answer.

A SwiftUI transition that refused to animate, and the two-branch conditional that was quietly destroying the view every time.

Coming from Swift, I fought Rust's borrow checker for a month. The model that made it stop being a fight.

Swift made existentials explicit for a reason. Here is what the box does, and when a generic is the better answer.

A place for the notes that are too short to become a book.