Bienvenue dans cette série de billets de blog dédiée à l'exploration des code smells dans un code legacy. Je suis ravi de vous présenter le premier billet de cette série, qui vous accompagnera dans la découverte et la compréhension des enjeux liés aux code smells et à l'amélioration de votre code hérité.

Nous avons tous été confrontés à un moment ou un autre à un code legacy. Cet héritage d'un autre temps qui peut parfois sembler insurmontable. Que vous ayez repris le travail d'un collègue parti (ou votre vous du passé, nous avons tous à un moment de notre carrière participé à créer du code legacy) ou que vous deviez intervenir sur un projet existant, il est essentiel de connaître les signes avant-coureurs d'un code problématique pour mieux l'améliorer.

Dans cette serie d'articles, nous allons tenter d'explorer un certain nombre de code smells les plus courants dans un code legacy, comprendre pourquoi ils sont problématiques et comment les détecter efficacement. Ensuite, nous discuterons des approches pour refactorer le code et le remettre sur la voie d'une architecture saine et maintenable. Se familiariser avec les code smells est une étape cruciale pour transformer un code legacy en un code moderne et performant, tout en évitant les pièges qui peuvent nuire à la qualité du projet sur le long terme.

Code Legacy ?

Le code legacy fait référence à un code existant dans un système ou une application qui a été développé et maintenu depuis longtemps, souvent par plusieurs générations de développeurs. Ce code peut être difficile à comprendre, à maintenir et à faire évoluer en raison de sa complexité, de l'accumulation de fix temporaires, ou de l'utilisation de technologies obsolètes. Sans compter la documentation parfois incomplète, inexacte ou inexistante. Il existe toutefois des solutions pour refactorer le code, c'est à dire le réécrire de manière à le rendre plus maintenable et moins sujets aux bugs et aux erreurs. Pour cela, il faut d'abord identifier les code smells, appliquer les bonnes pratiques de développements et s'assurer de couvrir de tests la solution pour éviter toute régression ou comportement inattendu.

Une caractéristique fréquente d'un code legacy est l'absence de tests unitaires. Les tests unitaires sont essentiels pour vérifier que chaque composant individuel d'un logiciel fonctionne correctement et pour détecter rapidement les erreurs lors de l'évolution du code.

Mais nous reviendrons sur le sujet des tests unitaires dans un code legacy dans une autre série de billets de blog, concentrons nous pour l'instant sur les code smells.

Mais c'est quoi un code smell d'abord ?

Un "code smell" ou "code qui pue" dans la langue de Molière, est un signe de mauvaise conception, de manque de clarté dans le code qui rend sa maintenance et sa lisibilité difficile et peut entrainer une complexité grandissante dans le code. Les code smells ne sont pas des erreurs ou des bogues à proprement parler, mais plutôt des signes que le code peut être amélioré.

Les code smells sont souvent le résultat d'un manque de rigueur dans le code ne respectant pas les bonnes pratiques de développement et leur conséquence peuvent être désastreuse dans un code source. La complexité et le manque de clarté dans le code due aux code smells, augmentent le risque qu'un bug s'immisce entre les lignes. Il est donc essentiel de savoir les identifier et les corriger pour faciliter la maintenance et réduire les risques de bugs. Une fois le code nettoyer de ses codes smells, il est important d'établir une certaine discipline dans le respect des bonnes pratiques et de la maitrise du Clean Code.

Quelques exemples de code smells courants :

• Classes trop longue

Une classe trop longue indique une trop grande résponsabilité. Il est donc difficile de comprendre l'intention du code à sa lecture. Il convient donc de diviser la classe en plusieurs classes plus spécialisées, plus simple à maintenir.

• Méthodes trop longues

Une méthode trop longue rend difficile sa compréhension. Une solution serait de refactorer le contenu de la méthode en plusieurs petites methodes privées aux intentions plus explicites. Ainsi à la lecture de la méthode en lisant une succession de noms de méthode bien nommées et explicites, il est plus aisé de comprendre son intention, d'y apporter des modifications.

• Noms de variables ou de méthodes ambigus

Un autre code smell peut-être un nommage ambigus des noms de variable ou de méthode. Le risque ici, est d'induire en erreur le développeur sur l'intention et l'utilité de cette variable ou cette méthode. Il convient donc de trouver un nom explicite et clair sur les intentions de notre code. D'autant qu'aujourd'hui avec les outils d'auto complétion de nos IDE, il est aisé de créer des longs de méthodes ou de variables très long.

• Commentaires inutiles

Des commentaires inutiles autour de notre code ajoute du bruit à la lecture. Souvent, ces commentaires ne sont pas mis à jour et deviennent rapidement obsolète et inutile dans le code. Il est important de bien nommer son code, ses méthodes et ses variables pour rendre le code auto-documenté autant que possible.

• Duplication de code

Lorsqu'il est difficile de comprendre ce que fait une classe ou qu'il est nécessaire d'ajouter un comportement ou une fonctionnalité, certains sont tentés de copier/coller du code existant en renommant ce qui doit l'être. On retrouve alors une portion de code à plusieurs endroit du code source. Le risque ici est que certaines portions copiées évoluent, mais pas d'autres alors qu'elles ont potentiellement la même responsabilité et doivent avoir le même comportement. Cela augmente donc la complexité du code et peut-être source de bug et de comportement non souhaité. Il convient ici de factoriser ce code à un endroit et de l'utiliser partout ou c'est nécessaire.

Les risques que peuvent engendrer les codes smells

Les code smells dans un code peuvent entraîner plusieurs risques et problèmes potentiels pour un projet, parmi lesquels :

• Difficulté de maintenance : Un code mal structuré ou peu lisible rend la maintenance et l'évolution du code plus complexe et chronophage. Cela peut conduire à des erreurs lors des modifications ou des ajouts de fonctionnalités.

• Augmentation des coûts de développement : En ajoutant de la complexité de part son manque de clarté, les codes smells augmentent inéluctablement les temps de développement et de maintenance d'un code source, ce qui se traduit par une augmentation des coûts et des ressources nécessaires pour maintenir le projet à jour et fonctionnel.

• Impact sur la performance : La duplication de code ou la complexité accidentelle, peuvent avoir un impact négatif sur les performances du code entraînant des temps de réponse plus longs ou une utilisation inefficace des ressources matérielles.

• Impact sur l'expérience utilisateur : Les problèmes de performance, les erreurs et les bugs résultant de code smells peuvent affecter la qualité globale du logiciel et entraîner une insatisfaction des utilisateurs finaux.

Pour minimiser ces risques, il est important d'identifier et de corriger les code smells dès que possible, en appliquant des pratiques de développement et en adoptant des principes de conception solides.

En savoir plus

Accompagnez-moi dans cette aventure pour identifier et combattre les code smells, et redonner vie à un code legacy en perte de vitesse.