Thibault on Simple Enough Blog

Thinking Top-Down in a Complex World

Thu, 26 Feb 2026 17:30:00 +0100

I. Two Fundamental Ways of Reasoning

When we observe how we design complex systems today — DevOps infrastructures, distributed platforms, modern software, or even educational pathways — we almost always find the same intellectual tension. On one side, there is a progressive and incremental approach, which starts from the basics and moves toward something more elaborate. On the other, there is an outcome-oriented approach, which begins by defining a goal, then works backward to determine what is needed to achieve it.

Test-Driven Infrastructure: Applying TDD to Infrastructure as Code

Wed, 14 Jan 2026 13:45:30 +0200

Test-Driven Infrastructure

Applying TDD to Infrastructure as Code

Test-Driven Development (TDD) is now well established on the application side.
However, when it comes to infrastructure, many still consider TDD unnecessary, too complex, or unsuitable.

That is a mistake.

TDD applied to infrastructure already exists, often without being named as such. When properly understood, it becomes a major lever for securing, structuring, and evolving a cloud platform.

Using Constants in TDD with Go

Tue, 23 Dec 2025 10:08:49 +0200

Best Practices, Pitfalls, and Design Signals

Test-Driven Development (TDD) is not only about writing tests.
Its primary purpose is to design software.

In Go, the use of constants is often misunderstood in TDD:

should they be exposed?
tested?
injected?
avoided?

This article proposes a pragmatic and idiomatic Go approach, based on real-world experience, to understand when a constant represents good design… and when it hides a deeper problem.

Interfaces, Functions and Modules in Go: Structuring Your Code for TDD Without Adding Unnecessary Complexity

Mon, 15 Dec 2025 10:08:49 +0200

I. Introduction

Go is a minimalist language, but this simplicity can sometimes make developers feel like something is “missing” — especially when dealing with more advanced architectures, Test-Driven Development, or the need to mock dependencies. Developers coming from Java, C#, or Python often ask the same questions:

Should I turn all my functions into structs + interfaces to test them?
How should I organize my packages to keep them modular and testable?
Where should interfaces live — in the provider or the consumer?
How do I isolate a package that only exports functions?
How does Go automatically detect signature changes?

II. Go’s Model: Simple, Modular, but Different

Unlike Java or C#, Go does not rely on inheritance, classes, or heavy dependency injection frameworks.

Consumer-Reported Dependency Health

Mon, 08 Dec 2025 11:18:06 +0200

I. Rethinking How We Evaluate the Health of Distributed Systems

In modern distributed architectures, a system’s health depends as much — if not more — on the state of its dependencies as on its own internal state. Yet most monitoring strategies still rely on synthetic or dedicated healthchecks: /health endpoints, liveness/readiness probes, external scripts, and similar mechanisms.

How to Handle Optional Parameters in Go

Sat, 15 Nov 2025 10:00:00 +0200

I. How to Handle Optional Parameters in Go

In most modern languages, you can define default values for function parameters or overload functions to cover various use cases.
Go, however, offers no optional parameters, no overloading, and no default values in function signatures.
Yet the needs remain the same: creating readable, stable APIs that can evolve without breaking users.