Posts

Technical blog posts, field reports, and opinions about Swift, software design, and programming in general. Nothing here is written by an AI.

CalendarDate

Swift code for handling Date objects at calendar date-granularity

Publish your iOS app faster by offloading key features

If you plan your project well, you can include key functionalities without needing to do much custom implementation, by relying on vanilla features included in the iOS development ecosystem. This post is about some things you can offload to get your app out the door faster.

Bizarro inheritance

When you really think about it, what *is* inheritance in object orientation? Intuitively, we tend to think of it as an "is a"-relationship. A car *is a* vehicle. A house *is a* building. A dog *is an* animal. But from a programming language perspective, the way it works can be expressed in a different way — as "has a" + fancy syntax.

Double optional bindings or something idk

I soon ran into a use case where I wanted to use an optional to control showing an edit sheet, and to indicate to that sheet whether it should edit or create an item. Interestingly, this implies that the correct type for the item binding is an optional of an optional item — Double optionals or something idk. The outer optional is the binding that controls showing the sheet. The inner optional indicates whether the item to edit is new or an existing item.

The resume as a software micro-project

The process of producing a CV to apply for a role is a lot like releasing software to production. Rather than being a once-off assignment, the content of a CV is quite fluid. Experience and skills get added, yes, but furthermore, each job application requires you to cater the resume to appeal to the specific job.

Measuring things is magic

Measuring things that we can influence, and making those metrics visible, tends to encourage us to perform well at those things. We can use this in our professional environment to improve our teams’ performance at certain important capabilities. But remember that it's important to measure the right things

DORA metrics — How competitive is your delivery pipeline?

So you think your team is good at delivering value for your clients. Maybe you even consider yourself elite. But how sure are you? How do you measure it?

Verify collections with sized index sets

Let's implement a concept that I'll call sized index sets* Another way to think about them is to call them exact numbers of indices. They're a little confusing, because they represent two ideas that seem different, but are really two sides of the same coin.

Acronyms in camel case should not be uppercased

This is a (strong) opinion I hold with regards to coding conventions. You know what an acronym is — it's just an abbreviation consisting of letters from a longer phrase, such as URL (uniform resource locator), NASA (National Aeronautics and Space Administration), or GIF (Jraphics Interchange Format - just kidding).

Magic version bumps for Github PRs

This post is about a configuration that I added to my a Github repo that I'm working on to make it automatically commit a version bump whenever someone merges a PR with a special label, and the hoops that I had to jump through to make it work.

Your app needs feature toggles

Let's talk about what feature toggles are, three good reasons why they're essential for mobile apps, and a strategy for implementing them.

Let’s make a Swift property wrapper that ignores variables when en/decoding

In this post, we create a property wrapper that can be used to “skip” properties when encoding or decoding an object. This is useful when we want to add properties to an object that we don’t need to encode, especially if those properties are not codable themselves.

What property wrappers can't do

Every time I see an opportunity to make something easier with PWs (which is what the cool kids call them), it turns out that my use case is just not supported. Why not? Because in Swift, a property cannot be both wrapped and lazy.

Swift protocol witnesses in 6 examples

In short, the idea is to represent a protocol as a struct. Clients that need to access functionality as defined by the protocol can do so by accessing members of an instance of the struct. Types do not declare conformance to protocols; instead, they provide global instances of the struct, binding their conforming implementations to those instances.

A simple state machine in Swift

I try to write Swift code in a more protocol-oriented way these ways, to make it easier to decouple things down the line. So let's start by declaring an interface for our state machine

An easy-to-use routing system in Swift

How we eschewed pre-built routing frameworks for a hand-rolled system based on protocols, enums and default implementations that is tailor made to our codebase

Swift: De-duplicate Tedious Type Declarations with In-line Configuration

Adding a configured method to variable types to help you organise your code while keeping things concise.

Swift: moving generics types from angled brackets to factory method parameters

Generics are powerful and expressive, but occasionally, they can get a little ugly. This article suggests a simple way to instantiate objects of generic types in Swift so that the roles of the generic types are clear, and to allow for more visually pleasing formatting.