Welcome to my blog on Arnaud Langlade

Build less to deliver better: the real cost of unnecessary features

contact@arnaudlanglade.com (Arnaud Langlade) — Tue, 14 Apr 2026 00:00:00 +0000

When a product grows, teams often think their problems come from technical complexity.

People often blame technical debt, complex code, or the lack of tests.

Building software is not just writing code

contact@arnaudlanglade.com (Arnaud Langlade) — Sun, 05 Apr 2026 00:00:00 +0000

I have seen many teams produce code, sometimes of very good quality, without really delivering value.

Not because they lacked skills. But because the conditions to deliver properly were not there: a feature that was too big, no user feedback, a fragile technical foundation, or deployments that were too risky.

Fullstack: someone who is expert in nothing?

contact@arnaudlanglade.com (Arnaud Langlade) — Sat, 28 Mar 2026 00:00:00 +0000

You have probably already heard this sentence:

“A fullstack developer is someone who is expert in nothing.”

A few years ago, I thought the same.

The repository design pattern

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 08 Apr 2024 00:00:00 +0000

The repository is a valuable design pattern for managing the persistence and retrieval of domain objects. It ensures a clean separation between the domain model and the persistence model, aiming to hide the complexity of the object’s state storing.

SOLID principles: Understanding the single responsibility principle

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 18 Mar 2024 00:00:00 +0000

The single responsibility principle (SRP) is the first of the five SOLID principles. It may be the simplest SOLID principles to understand, but it is not always easy to apply, especially if you’re a junior developer. What does this principle say?

SOLID principles: Understanding the dependency inversion principle

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 26 Feb 2024 00:00:00 +0000

The dependency inversion principle (DIP) is one of the SOLID principles. It is a crucial concept in object-oriented programming (OOP) because it highlights the importance of decoupling high-level modules from low-level modules. It helps to make code more modular, flexible, and maintainable by ensuring that high-level modules depend on abstractions rather than concrete implementations. Let’s have a look at the wikipedia definition and understand its meaning:

How I built MikadoApp, an open-source application for the Mikado Method

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 05 Feb 2024 00:00:00 +0000

In this blog post, I will explain how I built MikadoApp and the choices I made. If you are not familiar with the Mikado Method, I encourage you to read the blog I’ve written to understand how you can break down a big task into smaller ones:

Three types of React components for an effective testing strategy

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 15 Jan 2024 00:00:00 +0000

Automated tests are crucial for building robust software. They allow you to enhance existing features or add new ones without pressure because they ensure the application works without regression.

Testing a React application: Secure your tests from internationalization impact

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 11 Dec 2023 00:00:00 +0000

In my previous company, we automated the translation process. We used Lokalise, a cloud-based localization and translation management system. The developers imported all translation keys into the system, while the OPS team was responsible for translating all the keys.

The Mikado Method: Small Steps, Big Improvements

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 27 Nov 2023 00:00:00 +0000

In this blog post, I will introduce the Mikado Method. This method helps solve complex problems without breaking your codebase, even if you need to introduce significant changes.

Open-Closed principle: Enhancing code modularity

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 13 Nov 2023 00:00:00 +0000

Have you missed my last blog post about the pitfalls of inheritance ? I explain how it could be a bad idea to use it too much. Applying composition prevents this problem; it is better to work with small classes to easily assemble. In this blog post, I will talk about the open-closed principle. This principle facilitates composition and helps avoid relying too much on inheritance.

The pitfalls of OOP's inheritance: Why simple isn't always better

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 23 Oct 2023 00:00:00 +0000

In OOP, the simplest way to change the behavior of a class A is to create a class B that extends class A. Extensions allow you to override any public and protected methods of the parent class. That‘s quite simple, right?

Why breaking encapsulation is not a good idea

contact@arnaudlanglade.com (Arnaud Langlade) — Tue, 19 Sep 2023 00:00:00 +0000

In this blog post, I would like to speak about an important concept in Oriented Object Programming which is the encapsulation principle.

Don’t test private methods

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 17 Jul 2023 00:00:00 +0000

It is pretty easy to make mistakes when you start testing your code. One of the first mistakes I made was to test private methods. Spoiler alert: it was a bad idea because I had to use reflection to make them public to access them. If you need to test a private method, it probably means that your code is not well designed

Ease testing thanks to the dependency inversion design pattern

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 19 Jun 2023 00:00:00 +0000

In this new blog post, I would like to speak about the dependency inversion design pattern. This pattern makes your code more modular and helps to improve codebase testability. It’s quite simple and super powerful.

Use composition instead of props drilling

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 22 May 2023 00:00:00 +0000

In this blog post, I would like to speak about how composition can improve your React codebase. It’s easy to add a lot of props to your component to make them configurable but it’s not a good idea.

How to use custom React hook to increase application testability

contact@arnaudlanglade.com (Arnaud Langlade) — Tue, 04 Apr 2023 00:00:00 +0000

In my previous blog, I spoke about reducing coupling in a React app to improve testing. Now I will show you how a custom React hook can increase testability.

How to reduce coupling in your React app

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 06 Mar 2023 00:00:00 +0000

Today, I would like to cover dependency injection in React. I worked with several frameworks using tools to build and inject dependencies. It is pretty convenient if you apply the dependency inversion principle because you can easily change a dependency with another one.

What is the difference between CQS and CQRS patterns?

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 06 Feb 2023 00:00:00 +0000

I recently found out that I did not grasp those design patterns. There are a lot of resources on the Internet about them but they are not always accurate. That’s a shame because they are pretty simple. I will share my understanding of them with you.

Hexagonal architecture by example

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 09 Jan 2023 00:00:00 +0000

In this blog post, I would like to explain the basics of hexagonal architecture thanks to a simple example: a product catalogue. The catalogue manager can add new products through a user interface and the nightly cron task imports new products from the ERP.

What is the event sourcing pattern?

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 28 Nov 2022 00:00:00 +0000

Event sourcing consists in storing all changes that happened to an application as a sequence of events instead of only storing the current state of the application. The sum of all events is the current application state. When I heard about this pattern a few years ago, I was really confused. I used to only persist the current application state in a database and that was fine! So I asked myself do I need that?

My feedback about example mapping

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 31 Oct 2022 00:00:00 +0000

Example mapping is a workshop that gathers tech and non-tech people to ensure everyone has the same understanding of the domain problem. It also helps clarify the acceptance criteria for a given story. Because it’s always better to understand what is expected and raise all bottlenecks before developing a story.

How I have learned programming by myself

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 17 Oct 2022 00:00:00 +0000

I am, what we call, a self-taught. I studied telecommunications and networks at school, unfortunately, I only learned the basics of programming. I had to learn and improve my skills by myself for many years during my free time. I did not take the easiest path to learn! That’s why I wanted to share with you my own experience and what I did to learn software development. I hope this post will help some of you.

Increase your test quality thanks to builders or factories

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 10 Oct 2022 00:00:00 +0000

In a previous blog post , I explained why it’s better to compare object instances instead of exposing their state to test them. This avoids breaking encapsulation and it does not have any impact on their design.

How to handle user permissions through command bus middleware

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 26 Sep 2022 00:00:00 +0000

Applying user permissions might be very complex and can lead to introducing a lot of accidental complexity to your application. In this blog post, I want to share with you how to do it by simply adding a middleware to your command bus.

The command bus design pattern

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 12 Sep 2022 00:00:00 +0000

What is a bus?

Let’s start with the basics, what is a bus? In computer science, a bus is a system that connects several components and transfers data between them. In software, those components are called middleware. A middleware processes an incoming request and returns a response. As you can see in the schema below, the main advantage of a bus is that it is highly customizable as you can add as many middleware as you want.

Objective: set up your projects more easily

contact@arnaudlanglade.com (Arnaud Langlade) — Wed, 02 Jun 2021 00:00:00 +0000

For the last decade I worked on several more or less complex projects. I often had problems with their installation. Sometimes, the project was not documented or the existing documentation was not up to date. I had to run commands but I did not understand all of them. When I got errors it was hard to understand what happened. That was not always simple.

Why unit testing can be hard?

contact@arnaudlanglade.com (Arnaud Langlade) — Mon, 03 May 2021 00:00:00 +0000

Unit tests are typically automated tests written and run by software developers to ensure that a section of an application (known as the “unit”) meets its design and behaves as intended

Why you should not expose objects' state to test them

contact@arnaudlanglade.com (Arnaud Langlade) — Tue, 13 Apr 2021 00:00:00 +0000

To introduce this topic, let’s have a look at the PHP documentation to understand how object comparison works using the comparison and identity operators.

Symfony, Hexagonal architecture and CQRS

contact@arnaudlanglade.com (Arnaud Langlade) — Tue, 30 Mar 2021 00:00:00 +0000

In this blog post, I will explain how I organized my last Symfony projects.I mainly use Hexagonal Architecture and CQRS. Keep in mind that I did not aim to implement these architectures strictly by the book. I only took concepts that helped me to create a straightforward and well-organized codebase.

Persisting entities without ORM

contact@arnaudlanglade.com (Arnaud Langlade) — Tue, 23 Mar 2021 00:00:00 +0000

Today, I will talk about persisting entities without ORM. First, I will introduce the repository pattern because it provides a good abstraction to manage object persistence. Then, we will see what are the impacts on the entity design.

OOP: how to build an object

contact@arnaudlanglade.com (Arnaud Langlade) — Wed, 10 Mar 2021 00:00:00 +0000

In this new blog post, I want to talk about object building more specifically about primary and secondary constructors. The primary constructor is the default way to build an object with all its dependencies. The secondary constructors provide other ways to build objects depending on use cases.

How to validate a command?

contact@arnaudlanglade.com (Arnaud Langlade) — Thu, 04 Mar 2021 00:00:00 +0000

In my previous blog post , I talked about command and command handler design patterns. I got several questions about data validation and how to give feedback to users. We are going to talk about several kinds of data validation in this blog post. We will start with domain validation, this validation ensures we can build our domain objects in a good state depending on business rules. Then, we will talk about command validation and how we can use it to give feedback to users when they submit data to the application.

Command and command handler design pattern

contact@arnaudlanglade.com (Arnaud Langlade) — Thu, 25 Feb 2021 00:00:00 +0000

This pattern is really interesting; it can help you handle use cases. A command represents the user’s intent, while the command handler performs the actions needed to achieve the use case. Let’s dig a bit into these two concepts.