Unskilled

Are we augmented by AI yet?

Tue, 07 Apr 2026 00:00:00 +0000

An update about AI-assisted coding was long overdue. Here is my fresh take about it (until it changes again in 6 months). Actually, I started writing this in January, but couldn’t get it right, came back to it multiple times. Things are going so fast these days.

I’ve been doing software engineering for the past 15 years, and code has been part of my life for 25. I’ve seen enough shifts, hype cycles, abstractions, and “this changes everything” moments to be cautious when a new one arrives.

Are we replaced by AI yet?

Thu, 14 Aug 2025 00:00:00 +0000

Sociologist Hartmut Rosa argues that modernitity isn’t just about going faster: it’s about acceleration. We accelerate on three fronts:

technology,
way of life,
tempo of social change, driven by external economic and cultural forces.

LLM coding hits the technical acceleration pedal hard. But here’s the paradox: as speed rises, understanding falls.

How much is a billion, really?

Wed, 05 Mar 2025 00:00:00 +0000

This might sound like a dumb question in many countries, so let me explain. In most of Europe, a billion is not a billion. The word “billion” in French or German, or “billòn” in Spanish is a number called “trillion” in the US. That’s something Europeans just get used to. When you read billion in English, it means “milliard” in French. But why’s that?

This is because of long and short scales, which are the names of these two power of ten naming systems - Europe and half of Africa are using large scale naming, aka Chuquet’s scale, and the US, Russia, the Middle East and the other half of Africa are using short scale naming.

On CAA and CNAME records

Sat, 14 Dec 2024 00:00:00 +0000

This is something I knew but never realized all the implications of: CAA lookups are not only about CAA records. They also involve CNAME records.

First, a quick recap: CAA DNS records are used to specify which Certificate Authorities (CAs) are allowed to issue certificates for a domain. For example, specifying letsencrypt.org in a CAA record means that only Let’s Encrypt is allowed to issue certificates for that domain, and that other CAs should refuse to do so.

Using copy with strings

Sun, 18 Aug 2024 00:00:00 +0000

The Go copy built-in copies things from a source slice to a destination slice.

func copy(dst, src []Type) int

It is not using generics, but Type here serves the same purpose. Or does it?

Not exactly! string is a little-known exception:

As a special case, [copy] also will copy bytes from a string to a slice of bytes.

Next time you need to work with strings while reusing a work buffer, copy might just be the perfect candidate to avoid ugly for rune loops.

Splittable and unsplittable functions

Tue, 13 Aug 2024 00:00:00 +0000

As I described in Preemption in Go: an introduction, function prologues contain a stack bound check, which triggers a stack growth on failure. The stack guard can be poisoned with a specific value by the runtime to force a goroutine to enter the stack growth algorithm, which can detect the poisoning and give the runtime a chance to preempt the goroutine at a safe-point.

However, there are ways to avoid preemption when needed. One of them is to use proc pinning, as sync.Pool does, but that’s a bit heavy.

Adding shorts

Wed, 31 Jul 2024 00:00:00 +0000

I use this blog to write about things that interest me, and hopefully friends, colleagues and strangers on the internet.

Unfortunately, I don’t write as much as I would like to. Writing big, in-depth posts takes a lot of time and effort, and time is something I don’t have much of, having a full-time job, freelance activities, side projects, and a family to take care of. Or maybe I’m just lazy, don’t judge me.

Sūtor, nē supra crepidam

Wed, 31 Jul 2024 00:00:00 +0000

Sūtor, nē supra crepidam

This latin expression means “let not the shoemaker go beyond shoes”, and is the root of the word ultracrepidarian, which describes someone that ignored this advice, giving opinions or advice on matters outside of their knowledge.

But how can we know what we don’t know? “For I was conscious that I knew practically nothing…” allegedly said Socrates. The Dunning-Kruger effect cognitive bias shows that people with limited competence in a particular area tend to overestimate their skills, while experts in that area tend to underestimate their skills.

Brandolini's Law in the GPT Era

Sun, 28 Jul 2024 00:00:00 +0000

I went from not knowing what GPT meant to using such models daily in just a couple years, and I am not even an “AI engineer”. After nearly 15 years paying the rent doing software engineering, I am stuck in an abusive love-hate relationship with generative AI - shouldn’t I have known better?

When I test models, I ask them tricky and complex questions, such as “list 10 things about golang preemption that no one knows about”. I tried this one on Claude 3.5 a few weeks ago, and it almost got me, although I consider myself as pretty knowledgeable about Go-related niche stuff. It came up with an obscure mechanism that I had never heard of, with a nice chart on the side. It was so well explained and believable that I ended up digging the source code to check if it was true. Of course, it wasn’t.

noCopy convention

Sun, 28 Jul 2024 00:00:00 +0000

In this post I briefly explain what is the noCopy convention in Go, and when/how to use it. This is nothing new, it dates back from 2016, but I think it is worth mentioning, as it is kind of a hack and the reasoning behind it is not that obvious.

Context

The noCopy convention is a way to tell linters that a structure should not be copied. End of the blog post. The rest of it is uninteresting details. Stop right there. You have been warned.

Coroutines in Go

Sat, 27 Jul 2024 00:00:00 +0000

Approximately a year ago, rsc wrote about coroutines, and more specifically why we’d need them in Go, what should the API look like, and how they could be implemented. I was pretty skeptical about that post, but I think I’ve come around after seeing them used in the shiny new iter package.

In this post, I’ll cover the current implementation of coroutines in Go, and their use in the iter package.

Preemption in Go: an introduction

Sun, 09 Jun 2024 00:00:00 +0000

In my post about the sync.Pool internals, I briefly touched on preemption, but I didn’t explain what it really is about. Let’s fix that.

If you are in France, like me, you just completed your income tax declaration. If the go runtime is the tax administration, cpu-time is money, and preemption would be a letter of reminder. Or a bailiff banging on your door if you’ve been naughty.

What is preemption?

Preemption is one of the ways the go runtime ensures fairness. It distributes the time between all goroutines, so that no goroutine can take all the cpu resources and starve the others. Not only other goroutines could starve, but scheduling could also be delayed, so this could derail into serious problems.

Why am I doing it?

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

Why are so many of us staring at screens for hours, reading and writing code? What is the motivation behind it? I am not sure there is an universal answer to this question. Do we like solving problems? Do we like the feeling of creating something? Or do we like the feeling of being in control? That sounds like the beginning of a therapy session.

Deconstructing Go's magical defer

Thu, 28 Dec 2023 00:00:00 +0000

This post is targetted at Go beginners, but can serve as a good refresher to more experienced gophers.

When starting out, defer feels magical, doesn’t it? Guess what: it’s not. In this blog post, we will let go of the magic to have a basic understanding of what is happening under the hood when using the defer statement.

This is your brain on false sharing

Tue, 05 Dec 2023 00:00:00 +0000

In this post, I make the case for being aware of false sharing situations in go. While diving into the sync.Pool internals, I stumbled upon some structure padding, which I had never considered as very useful performance-wise. Here, we’ll have a succinct refresher about false sharing, a few examples with benchmarks, and try to draw conclusions from it.

Refresher

If you’re familiar with false sharing, skip to the next section. If you need more clarification on it, keep reading!

Let's dive: a tour of sync.Pool internals

Sat, 25 Nov 2023 00:00:00 +0000

In this post we will uncover what makes sync.Pool so damn good. You will get practical insights on how and when to use it.

Introduction

The Pool implemention of the sync package of Go’s standard library is a valuable asset to leverage. Deeply integrated with the runtime, it is an efficient way to lower allocations and relieve the garbage collector.

General usage

Let’s start by looking at the general lifecycle of items. When creating a new Pool, you give it a New func() any, that is responsible for allocating items. Consider the following:

Bounds checking in Go

Wed, 15 Nov 2023 00:00:00 +0000

When accessing an element in a slice, you might go past its length. This is a typical off-by-one error, and fortunately there is a safeguard for this: bounds checking. It protects you from buffer overflow attacks and tells you there’s something wrong with your code - so thank you, bounds checking. Before accessing the element, the index is compared with the slice’s length to make sure it is within bounds. If it is not, runtime.panicIndex() is called!

Generics in Go: functional programming is finally here

Thu, 02 Dec 2021 00:00:00 +0000

Go 1.18 introduces generics as part of the language. This post describes how to use it and look at how it enables functional programming.

About

Fri, 26 Nov 2021 00:00:00 +0000

Welcome to my personal blog. I am a software engineer living in France, and I worked in the entertainment industry for 11 years before joining botify.com to passionately work with Go and genuinely nice and smart people. My work there is mostly about building systems to manage traffic and render webpages at scale, and I love it.

Did you spot an error? Awesome. Just want to say hi? Please do at hello@unskilled.blog.