A personal notebook on software

I like figuring
things out.

I'm Thibault, a freelance mobile architect. I write about the systems I build, the mistakes I learn from, and the ideas that make software easier to live with.

Side Effect logo Side Effect / 2026

01 / A little context

This is where I keep the ideas that survive the work.

After more than two decades in software—and a long love affair with Swift—I work with teams on mobile architecture, functional programming, and the small choices that make a codebase last.

02 / The name

Why “Side Effect”?

In functional programming, a side effect is where a program touches the world: a network call, a file, a user, a decision. I chose the name because that boundary is where software becomes real—and where careful design matters most.

03 / From the blog

Notes on building software.

View all articles
Concurrency

Debouncing with Swift concurrency

When developing an iOS application, it is a common need to handle the frequency at which information is processed. For example, when making changes to a search field, we might want to request a remote API for each update. However, sending too many requests in quick succession can cause the server to become overloaded. To avoid this issue, it is important to pace the requests in order to prevent overloading the server. One solution to this problem is to use reactive programming and apply a Debounce operator to a stream of user inputs. However, if you don't want to use reactive programming, async sequences, or third-party libraries, you can explore a solution using pure Swift concurrency. In this article, we will look at how to use this approach to manage the frequency of information processing in an iOS application.

Concurrency

AsyncSequence extensions

Swift 5.5 introduced structured concurrency, and with it came AsyncSequence, a new way to provide a flow of values over time. Wait, what? Isn't this what Combine is all about? From Apple, "The Combine framework provides a declarative Swift API for processing values over time". Are these technologies similar? Interchangeable? Well, sort of! In this article we will explore the differences and similarities between them and we will go over a repo that brings Combine-like operators to AsyncSequence.

language

Equatable Errors in Swift

Error is a base type in Swift that aims to represent an issue happening in the application flow; thus, it is very common to use it as an existential type that will cross the application layers. With Error being a protocol, we can implement our own custom errors making them Equatable if needed. In doing so we might have to leak implementation details across the application. This article explores a way to make an error conform to Equatable without compromising its abstraction.

architecture

A DSL for state machines in Swift

State machines are great tools to describe systems with a finite number of states. They are predictable and testable, which is something we praise for as developers. State machines can be defined in a pretty abstract way, which makes it a good candidate for a Domain Specific Language implementation. In this article, we will try to create a DSL that can describe state machines in Swift and use it in a feedback loop architecture.

04 / Open source & side projects

A few things I've built along the way.

Explore the projects and frameworks that have shaped how I think.

Explore projects