Welcome to my blog

Hi, my name is Arnaud. I am a software architect, and technical coach. I love sharing my knowledge about software engineering such as architectural design patterns, software testing, methodologies and so on.

SOLID principles: Understanding the dependency inversion principle

Explore the Dependency Inversion Principle (DIP), a key SOLID principle in object-oriented programming (OOP). Learn how to enhance code modularity, flexibility, and maintainability by decoupling high-level and low-level modules.

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

Discover how I built theMikadoApp, an open-source application leveraging the Mikado Method. Learn about technical choices, practices, and the steps to deploy an MVP. Discover the challenges faced and lessons learned in the development process.

Three types of React components for an effective testing strategy

Discover an effective strategy for testing React components by categorizing them into UI, Business, and Page components. Learn how to organize your codebase to facilitate testing for maintainable code.

Testing a React application: Secure your tests from internationalization impact

Learn how to prevent test suite breaks caused by translation changes through an innovative solution, ensuring resilience and flexibility in your testing approach.

The Mikado Method: Small Steps, Big Improvements

Enhance your codebase with the Mikado Method – a focused approach for incremental improvements without breaking your codebase. Tailored for brownfield development, ensure code stability and effortless feature integration. Collaborate effectively with MikadoApp and achieve rapid code enhancements through Trunk Based Development.

Open-Closed principle: Enhancing code modularity

Unlock the potential of the Open-Closed Principle in programming. Discover how to enhance code modularity and simplify maintenance using this SOLID concept. Learn to reduce complexity and write more flexible code.

OOP

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

Discover the complexities of excessive inheritance in object-oriented programming (OOP) and understand why careful consideration is crucial to avoid potential problems and pitfalls.

Why breaking encapsulation is not a good idea

This principle restricts direct access to the state of the object from outside. This means that the internal implementation details of a class are hidden. Accessing the state of the object is only allowed through its public API (public methods). This concept helps to protect the data from outside interference and ensures controlled and secure data manipulation.

Don’t test private methods

One of the first mistakes I made when I started to test my code was to test private methods. Spoiler alert: it was a bad idea! If you need to test a private method, it probably means that your code is not well designed. Private methods are implementation details of objects and we should not care about them. When you test public methods you also test the private ones.

Ease testing thanks to the dependency inversion design pattern

The inversion design pattern is quite simple and super powerful. It makes your code more modular. It lets you change a class's dependency to another one depending on the context. It is a good way to decouple your code from IO to make it testable.

Use composition instead of props drilling

Adding too many props will make your components complex, hard to understand and maintain. Instead opt for several small components and apply composition. Learn how in this blog article.

How to use custom React hook to increase application testability

Sometimes, we depend on libraries that provide components which cannot be well rendered in the test environment. That means we cannot test some parts of an application. Learn how to use a React hook to prevent that problem and increase the application testability in this new blog article.

How to reduce coupling in your React app

The dependency inversion principle is a great design pattern, it makes applications more modular and easier to test. A React Context can help to implement this pattern in a React application. Learn how in this new blog article.

What is the difference between CQS and CQRS patterns?

CQS and CQRS are misunderstood design patterns. They are more simple than people think! CQS is about dividing an object's methods into two categories: commands and queries while CQRS is about separating query and command into two objects.

Hexagonal architecture by example

The hexagonal architecture, or ports and adapters architecture, is an architectural pattern used in software design. It aims at creating loosely coupled application components that can be easily connected to their software environment by means of ports and adapters.

What is the event sourcing pattern?

Event sourcing consists in storing all changes that happened to the application state as a sequence of events instead of only storing the current state of the application. The sum of all events makes the current application state.

My feedback about example mapping

Example mapping is a good way to align the team's understanding of domain problems and help your team to better collaborate. Last but not least, it eases to refine your stories and improve your backlog prioritization.

How I have learned programming by myself

Learning is an important part of our job. It is not that easy when you don’t know where to start, especially if you're self-taught like me. I share what I did to learn software development for the last 15 years in this blog post.