Blog – Victor Pierre

Aligning Go struct fields to save memory

Sun, 28 Jun 2026 00:00:00 +0000

A printer’s composing case

each sort of movable type packed so no space is wasted.

Building a Personal Knowledge System with Obsidian

Thu, 22 Jan 2026 00:00:00 +0000

Aztec obsidian blade

Louis Petich Collection, 13th–16th century.

I tend to write things down a lot. I like to write notes during meeting, as I think through problems, as I need to prepare for a presentation, or a large task, or when I just need to remember something later, that I know I’ll forget.

But the problem is that, with so many notes, it’s hard to find what I’m looking for. I’ve tried various tools over the years to keep things organized, and Obsidian has been by far my favourite. I would prefer something open source, but for my workflow, nothing else comes close.

Dual-Writes and the Outbox Pattern

Sun, 18 Jan 2026 00:00:00 +0000

The Great Courier

Alois Petrak (Czech, 1811–1888).

Your daily reconciliation job flags a problem: dozens of orders exist in your database, but no corresponding events ever reached Kafka. The email service never sent confirmations. The inventory service never reserved stock. After some digging, you find the culprit - Kafka had a brief hiccup yesterday and returned errors for a few publish attempts. The database writes succeeded, but without the outbox pattern, those events were simply lost.

Cooperation Without Dependency

Tue, 06 Jan 2026 00:00:00 +0000

Allegory of the 1st Partition of Poland

the European powers carving up a nation.

“The greatest danger in times of turbulence is not the turbulence; it is to act with yesterday’s logic.”

— Peter Drucker

The institutional order built after 1945 is fraying. I did not expect to be writing in 2026 about digital infrastructure as a matter of national security. Yet here we are: the critical systems of Western democracies sit concentrated in foreign jurisdictions, vulnerable precisely when stability matters most.

2025 - Retrospective

Mon, 22 Dec 2025 00:00:00 +0000

As we approach the end of 2025, I want to reflect once again on what I’ve experienced and learned this year, as well as my hopes and goals for the next. I’m reminded of how fortunate I am to have had the experiences and opportunities I’ve had.

Personal

I’ve revived an old hobby: photography. This is something I’ve always enjoyed. I remember when I was 10 or 11, my parents got me an old Kodak Instamatic 333-X (I think) camera that was popular in the 60s and 70s. By the 90s, it was being rebranded and promoted as a cheap camera for kids, complete with Disney characters and all. I must still have some of those random pictures at my parents’ house.

Distributed Tracing in Go

Wed, 08 Oct 2025 00:00:00 +0000

Silk-throwing by hand

the thread traced between two fixed points. (The Penny Magazine, 1843)

Stacked git branches with git-spice

Thu, 05 Jun 2025 00:00:00 +0000

Ever find yourself working on a feature that requires either creating a massive PR, which is hard to review, or waiting for each small change to be merged before you can proceed? Implementations that can naturally be broken into smaller PRs, but it is hard to keep them in sync as you get reviews requiring changes.

2024 - Retrospective

Wed, 01 Jan 2025 00:00:00 +0000

As 2024 draws to a close, I want to put into words my year-end reflection. It’s been an eventful journey filled with opportunities and unexpected changes.

Personal: I feel so lucky

Despite worrisome global events, I find myself profoundly grateful for my personal circumstances - I’m in good health, I love what I do for a living, and I’m always surrounded by better people than me.

Reproducible macOS Configurations with Nix

Tue, 09 Jul 2024 00:00:00 +0000

What is Nix?

Nix is a powerful package manager ¹ for Linux/Unix systems that offers a declarative approach to system configuration. With Nix, you define your system’s state in a configuration file (known as a flake), ensuring that your setup is reproducible across different machines.

A key component of the Nix ecosystem is Nixpkgs, the default repository of Nix packages, which contains thousands of searcheable packages that you can easily integrate into your configuration.

User-centric feature design

Sun, 26 May 2024 00:00:00 +0000

Early in my career, I learned that the most successful features were those designed with the user in mind. Through regular client demos and feedback sessions, I discovered that keeping users at the center of the design process was essential. As I’ve moved to larger companies where users are less accessible and engineers focus more on implementation, I’ve maintained this user-first approach.

Resilience and Mental Wellness in Uncertain Times

Sat, 17 Feb 2024 00:00:00 +0000

The Gulf Stream

Winslow Homer, 1899.

Hasten Slowly in Software Development

Sun, 24 Dec 2023 00:00:00 +0000

The dolphin and anchor

Aldus Manutius’s printer’s mark for festina lente.

Legend has it that the Roman Emperor Augustus Caesar held a particular fondness for the maxim Festina Lente, loosely translated as Make Haste Slowly or More Haste, Less Speed. This seemingly paradoxical phrase harbours deep wisdom, encapsulating the art of balancing swift action with thoughtful deliberation. Its essence lies in the understanding that the most expedient path to a goal is not through hurried, reckless efforts, but through measured, considered progress that avoids the pitfalls of undue haste.

Go Interfaces: Five Best-Practices for Enhanced Code Maintainability

Wed, 13 Dec 2023 00:00:00 +0000

When you’re coding in Go, you’ll quickly come to appreciate interfaces. An interface in Go is a type that spells out a set of methods. But here’s the interesting part: Go does things differently from other languages. Instead of needing an explicit declaration, a type in Go automatically satisfies an interface as long as it has all the required methods.

Enhancing Data Access with the Decorator Pattern in Go

Sun, 03 Dec 2023 00:00:00 +0000

Matryoshka dolls

each shell wrapping the next.

The decorator pattern is a structural design pattern that allows augmenting an object’s behaviour without altering its core structure. In Go, this pattern is especially powerful when separating concerns like caching, logging, or instrumentation from your core business logic.

In Go, since there is no direct support for classes and inheritance as in some other languages like Java or C#, the decorator pattern is typically implemented using interfaces and embedding. This article will explore how to implement the decorator pattern in Go and how to leverage it to create a robust data access layer with stackable functionalities.

A Beginner's Guide to Semantic Versioning

Sun, 09 Jul 2023 00:00:00 +0000

Semantic Versioning (SemVer) is a versioning scheme used in software development to provide a systematic approach for managing version numbers. It’s common for developers to initially find SemVer confusing, especially regarding version increments and release candidates. Understanding SemVer begins with grasping the problem it solves.

Purpose of Semantic Versioning

Semantic Versioning primarily aims to communicate meaningful information about software releases. By adopting a structured versioning scheme, developers understand the implications of new versions, such as breaking changes, new features, or bug fixes. SemVer ensures compatibility and predictability in dependent software components by defining clear rules for version number increments.

Understanding Zero Values in Go

Thu, 20 Apr 2023 00:00:00 +0000

In Go, variables of basic types such as int, float64, bool, string, and others, will have a default value that is assigned by the compiler or runtime when no value is explicitly assigned to it (they are declared but not initialized). This is called a “zero value”.

The concept of zero values is important because it allows programs to work with variables even if they have not been assigned a value yet. This is useful in situations where a default value is sufficient or when a value will be assigned later in the program.

Escaping the internet's walled gardens

Fri, 16 Dec 2022 00:00:00 +0000

The Balsam Garden of Cairo

a walled garden under guard. (14th century)

The Internet has undergone a significant change over the years, shifting from decentralization to centralization. In the early days, many networks and servers connected to form a distributed structure, allowing an open and free flow of information, competition, and innovation. However, the internet of today is controlled by a few major tech companies, leading to a less open and more controlled online space. This concentration of power and control has led to the creation of “walled gardens” with many users being restricted to accessing only the content and services provided by these major tech companies.

How I organize (most of) my Go microservices

Sun, 06 Nov 2022 00:00:00 +0000

When first learning Go, my initial instinct was to find a framework that would scaffold the basic folder structure and functionality that would allow me to build my first project. It didn’t take long to realize that Go, thanks to its rich standard library ecosystem, didn’t really need a framework, and often the framework works against you. Since then, I’ve welcomed many new developers to my team who were used to working with different programming languages. Some of them have been surprised by the lack of a consistent folder structure across different parts of our company’s codebase.

End-to-End tests with Venom

Fri, 17 Dec 2021 00:00:00 +0000

Glass beaker with snake-thread decoration

Roman, Gallia Belgica, 4th century CE.

What is Venom?

Venom is an Open-Source tool for writing automated end-to-end and integration tests. It is published by OVH, a French cloud company. It is built on top of a popular Go framework called Cobra (hence the name). It aims to be easy and simple to use. It doesn’t require you to write your testCases in Python/Java/JavaScript like many other e2e testing tools. You declare your test cases using a simple .yaml file that resembles CI job declarations. It is written in go and can be easily extendable.

An introduction to Protocol Buffers 3

Sun, 09 May 2021 00:00:00 +0000

A little bit of context first:

I’ve spent most of my professional life building RESTful APIs. Recently I had to build a gRPC service, and learning protobuf for the first time seemed to be a daunting task. It turns out, Protocol Buffer is very easy to learn, feature-rich, and can speed up development significantly.

If you are looking into protobuf for the first time, my goal in this post is to give you an initial overview of the Protocol Buffer 3 syntax, structure, data types, and best practices.

Five useful terminal tools for Developers

Tue, 25 Aug 2020 00:00:00 +0000

As a software developers, the terminal is an essential tool in our workflow. It provides a powerful interface to interact with the operating system and execute various commands. While most developers are familiar with basic terminal commands, there are many useful applications that can streamline your workflow and improve productivity. In this blog post, we will discuss five such terminal applications that every developer should know about. Whether you are a seasoned developer or just starting, these applications can help you work more efficiently and effectively in the terminal.