What is a software craftsman?

Before continuing to read, I recommend checking out my article "What is the Agile methodology?" to better understand what follows.

A software craftsman, (sometimes called "développeur artisan" or "Software Craftsman" in English) is a developer who applies the philosophy described in the software craftsmanship manifesto in their work.

Software craftsmanship isn't an alternative philosophy to Agile design, it's actually an extension of it. Originally, "Software Craftsmanship" was even proposed to become the 5th rule of the Agile manifesto, but this decision was not unanimous.

What you need to remember is that a software craftsman is first and foremost an Agile developer.

The manifesto

The software craftsmanship manifesto therefore builds on the 4 principles of the Agile manifesto, while evolving them:

1. Not only working software, but also well-crafted software.
2. Not only responding to change, but also steadily adding value.
3. Not only individuals and interactions, but also a community of professionals.
4. Not only customer collaboration, but also productive partnerships.

The first thing we can notice is that, through the words used, this manifesto tends to convey a vision of longevity, which transcends the simple idea of a project and a product to fit into the longer term.

The values of the software craftsman

Behind this manifesto and this general idea of sustainability lie underlying values shared by craftsmen, which constitute a true philosophy:

Among these values, we find for example:

• quality (robustness of the software)
• professionalism
• know-how
• sharing of experience
• humility (self-questioning)

To make a living from their work while respecting these values, the craftsman must put in place tools and methods to facilitate their daily work and improve the quality of their work.

The tools/methods of the software craftsman

It is important to note that software craftsmanship is not a mold within which all followers use the same tools, so the ones presented below are just examples.

We could say that there are as many ways of doing software craftsmanship as there are craftsmen.

For code quality, a "Craftsman" will for example rely on design methods, patterns and paradigms to make the software more robust or the code cleaner.

For example, we find:

• KISS (Keep It Simple, Stupid), DRY (Don't Repeat Yourself), SOLID
• OOP (Object-Oriented Programming)
• DDD (Domain-Driven Design)
• TDD (Test-Driven Development)
• And many others.

Note that while TDD is not necessarily used by ALL software craftsmen, tests (unit, integration, non-regression, etc.) hold a very important place in the craftsman's life.

For knowledge sharing, one can set up pair-programming or mob-programming sessions for example, a working method that consists of working together on the same machine.

If "pair-programming" interests you, I've written a detailed article on this topic which I invite you to read.

But participating in conferences, workshops, podcasts, or even writing a technical blog is also a good way for a craftsman to pass on their knowledge.

Regarding project management, running things in SCRUM will allow the craftsman, for example, to question themselves and think (collectively) about ways to improve their work at the end of each sprint, during the retrospective.

Going further

This article remains an introduction to the principles of software craftsmanship, which in practice is a more complex philosophy.

If you're interested in the subject, I invite you to read the book by one of the pioneers of software craftsmanship: Clean Code by Robert C. Martin

Otherwise, there are some excellent podcasts, like the one by Benoit Gantaume called "Artisan Développeur", which I talk about in my article "4 must-listen podcasts for French-speaking developers".