Clean Code : Ecrire du Code Lisible et Maintenable

Qu’est-ce que le clean code ?

A l’origine

L’idée de produire un code propre remonte aux débuts de l’informatique, mais elle a pris une importance particulière avec l’essor des projets collaboratifs. Linus Torvalds, créateur du noyau Linux, a été l’un des premiers à insister sur la lisibilité du code.

Il soulignait qu’un code écrit pour être partagé devait être compréhensible par tous, pas uniquement par son auteur.

Cependant, le concept de clean code a véritablement été formalisé par Robert C. Martin (dit « Uncle Bob » ) dans son livre clean code: A Handbook of Agile Software Craftsmanship, publié en 2008.

Ce livre est devenu une référence incontournable pour les développeurs Java souhaitant améliorer la qualité de leur code. Martin y décrit les principes et les bonnes pratiques nécessaires pour écrire un code propre, et explique pourquoi cela est crucial pour garantir la pérennité des projets.

Le clean code aujourd’hui

De nos jours, le concept de clean code s’est adapté aux spécificités des différents langages de programmation. Chaque langage dispose maintenant de ses propres conventions, outils et styleguides pour coder proprement.

Pourquoi le clean code est-il si important ?

Le clean code n’est pas un luxe, c’est une réelle nécessité dans tout projet de développement. Cela permet de :

• Réduire les bugs
• Faciliter la maintenance
• Améliorer la collaboration

Adopter le clean code c’est donc non seulement coder proprement pour soi-même, mais aussi pour ceux qui travailleront sur le code à l’avenir.

Comme l’a dit Robert C. Martin :

Un bon code est comme une bonne prose - il doit être lisible et clair.”

Et comme nous sommes des artistes, il a raison ! 😉

Comment adopter le clean code ?

Ecrire du code lisible et maintenable ne se fait pas au hasard. Cela repose sur un ensemble de bonnes pratiques et d’outils qui permettent d’atteindre cet objectif.

Voici quelques petits conseils pour commencer à coder proprement.

#1 Suivre des styleguides

Comme évoqué précédemment, les styleguides sont des documents qui définissent des conventions de codage à respecter pour un langage ou un projet.

Ces conventions peuvent concerner :

• La manière de nommer les variables
• D’appliquer des règles syntaxiques spécifiques (indentation, retour à la ligne, etc.)
• L’usage de commentaires
• Etc.

Voici quelques exemples de styleguides réputées :

• En Python, le PEP 8 est guide de style standard
• Le Airbnb Style Guide est très largement utilisé dans l’écosystème JavaScript
• Pour Java, on suit souvent les conventions Oracle ou Google

Il existe également des outils qui contribuent à assurer un code propre comme :

• Prettier : formatage automatique du code
• Black : formateur de code pour python
• ESLint : analyse et correction de code JS

Ces outils permettent de garantir une cohérence dans le code, même au sein d’une grande équipe, en respectant les normes du langage choisi.

#2 L’indentation

L’indentation est une pierre angulaire du clean code. Un code bien indenté améliore la lisibilité et facilite la compréhension des structures imbriquées, comme les boucles ou les conditions.

Voici un exemple d’indentation :

def afficher_utilisateurs(utilisateurs):  
    for utilisateur in utilisateurs:    
        print(f"Bienvenue {utilisateur.nom}")

La plupart des IDE permettent de formater automatiquement le code en respectant les conventions d’indentation. Cela peut être très utile pour gagner du temps et rester cohérent tout en évitant les erreurs.

#3 Les commentaires

Les commentaires sont utiles pour clarifier des portions de code complexes, mais ils doivent être utilisés avec parcimonie.

Un bon code se suffit à lui-même : chaque ligne devrait être explicite. Les commentaires doivent compléter le code et pas le remplacer. Autrement dit, les commentaires expliquent les pourquoi, pas les comment.

❌ Exemple de mauvais commentaire :

# Boucle sur les élements
for i in range(10):
    print(i)

✅ Exemple de bon commentaire :

# Vérifie si l'utilisateur a l'âge légal pour s'inscrire
if utilisateur.age >= 18:
    valider_inscription(utilisateur)

#4 Nommer les variables et les fonctions clairement

Un bon nom peut éviter des commentaires inutiles. Les variables, fonctions, et classes doivent avoir des noms clairs qui décrivent leur rôle ou leur contenu.

Voici quelques exemples :

# ❌ Mauvaise pratique
a = 35

# ✅ Bonne pratique
nombre_notes = 35

#5 Réduire les complexités

Le clean code privilégie des méthodologies simples à respecter. Il existe de nombreux principes qui permettent de réduire la complexité du code, comme KISS, DRY, YAGNI et SRP.

KISS (Keep It Simple, Stupid)

La méthodologie KISS vise à réduire la complexité du code en privilégiant la simplicité.

Il s’agit de choisir la solution la plus simple pour résoudre un problème, sans chercher à le compliquer inutilement.

# ❌ Complexe : beaucoup trop d'éléments pour une tâche simple
def calcul(x, y, operation):
    if operation == "addition":
        return x + y
    elif operation == "soustraction":
        return x - y
    else:
        return "Opération non prise en charge"

# ✅ YAGNI : une méthode pour chaque tâche
def addition(x, y):
    return x + y

def soustraction(x, y):
    return x - y

DRY (Don’t Repeat Yourself)

Le principe DRY consiste à réutiliser le code plutôt que de le dupliquer.

Cela permet de réduire la taille du code, d’éviter les erreurs et de faciliter la maintenance.

# ❌ Mauvais : logique répétée
def valider_email(email):
    if not email or "@" not in email:
        return "L'email doit contenir un '@'."
    return "Email valide."

def valider_mot_de_passe(mot_de_passe):
    if not mot_de_passe or len(mot_de_passe) < 8:
        return "Le mot de passe doit contenir au moins 8 caractères."
    return "Mot de passe valide."


# ✅ DRY : regrouper la logique
def valider_entree(valeur, condition, message_erreur):
    if not condition(valeur):
        return message_erreur
    return "Entrée valide."

# Réutilisation pour différentes validations
def valider_email(email):
    return valider_entree(email, lambda x: x and "@" in x, "L'email doit contenir un '@'.")

def valider_mot_de_passe(mot_de_passe):
    return valider_entree(mot_de_passe, lambda x: x and len(x) >= 8, "Le mot de passe doit contenir au moins 8 caractères.")

YAGNI (You Ain’t Gonna Need It)

Le principe YAGNI consiste à ne pas implémenter de fonctionnalités tant qu’elles ne sont pas absolument nécessaires.

Cela fait référence à des fonctionnalités qui sont souvent ajoutées “au cas où”, mais qui ne sont jamais utilisées.

Un code non YAGNI, c’est :

• Une complexité superflue : le rendant plus difficile à comprendre et maintenir.
• Un risque accru de bugs : dû à des fonctionnalités inutilisées ou mal testées.
• Une perte de temps : causée par le développement et la maintenance de besoins non nécessaires.
• Un projet alourdi : impactant l’équipe et les performances globales.

SRP (Single Responsability Principle)

Le principe SRP stipule qu’une classe ou une fonction doit avoir une seule responsabilité.

❌ Mauvais : Une seule classe gère plusieurs responsabilités : journalisation et calculs

class Calculator:
    def add(self, a, b):
        result = a + b
        print(f"LOG: Added {a} and {b}, result is {result}")  # Journalisation intégrée
        return result

✅ SRP : Chaque classe a une responsabilité distincte

class Logger:
    def log(self, message):
        print(f"LOG: {message}")

class Calculator:
    def __init__(self, logger):
        self.logger = logger

    def add(self, a, b):
        result = a + b
        self.logger.log(f"Added {a} and {b}, result is {result}")
        return result

#6 Écrire des tests

Le clean code ne s’arrête pas à la lisibilité ou à la structure du code, il englobe également la validation de son bon fonctionnement à travers des tests.

Les tests sont une partie essentielle du processus de développement, surtout en entreprise ou dans un environnement collaboratif. Bien qu’il soit parfois tentant de les ignorer pour « gagner du temps », cette approche peut entraîner des erreurs coûteuses sur le long terme.

Il existe plusieurs types de tests comme les tests unitaires, les tests d’intégration ou les tests E2E mais il en existe encore beaucoup d’autres qui vont venir confirmer le bon fonctionnement de votre projet.

Les tests sont cruciaux, ils permettent d’éviter les régressions. Il est possible de modifier ou ajouter du code en toute sérénité, sachant que les tests donneront l’alerte en cas de problème.

Ils renforcent également la confiance dans le code, un code couvert par des tests est plus sûr et plus stable.

Aujourd’hui il existe des outils modernes et adaptés à votre stack pour écrire des tests rapidement et efficacement. Pour les projets JavaScript ou TypeScript, Vitest est un excellent choix compatible avec beaucoup de frameworks.

Vous n’avez plus aucune excuse pour ne plus faire de tests. 😉