Code smells : guide du développeur

Qu'est-ce qu'un code suspect?

Les codes suspects sont définis comme des catégories de problèmes dans le code qui peuvent entraîner des problèmes plus graves à long terme. Ils s'apparentent à des indicateurs d'alerte qui apparaissent en raison de mauvaises pratiques de codage potentielles.

Bien que les codes suspects ne soient pas des erreurs ou des bogues en soi et n'affectent pas le fonctionnement du logiciel, ils indiquent des faiblesses dans la conception qui peuvent ralentir le développement ou augmenter le risque de bogues ou de défaillances à terme.

Parmi les exemples courants de code smell, on peut citer les classes volumineuses et les méthodes longues, c'est-à-dire une fonction qui essaie d'en faire trop, ou des méthodes longues à comprendre.

Un autre exemple est le code dupliqué, où le même morceau de code est répété à plusieurs endroits.

De tels problèmes peuvent entraîner un code lourd, augmenter la complexité cognitive de la base de code et contribuer à des problèmes de maintenabilité et à une dette technique accrue dans le logiciel.

Quels sont les exemples de code malodorant?

Le code Python ci-dessous a un score de complexité cognitive de 8 en raison de la manière dont les fonctions sont imbriquées. Bien que ce code fonctionne correctement, il ajoute une complexité inutile pour l'auteur, le réviseur et le futur développeur s'il n'est pas corrigé.

def process_user(user):

    if user.is_active():             # +1 (if)

        if user.has_profile():       # +1 (if) +1 (nested)

            ... # process active user with profile

        else:                        # +1 (else)

            ... # process active user without profile

    else:                            # +1 (else)

        if user.has_profile():       # +1 (if) +1 (nested)

            ... # process inactive user with profile

        else:                        # +1 (else)

            ... # process inactive user without profile

Pourquoi les odeurs de code sont-elles importantes ?

Les odeurs de code sont des indicateurs cruciaux de l'état d'un logiciel, car elles constituent des signes avant-coureurs de problèmes potentiels pouvant survenir dans la base de code. Elles sont importantes car elles permettent d'identifier les endroits où le code pourrait être vulnérable à des problèmes futurs, même s'il fonctionne correctement pour le moment.

Les développeurs peuvent prévenir les défauts de conception fondamentaux, les problèmes de maintenabilité et les problèmes d'évolutivité avant qu'ils ne deviennent plus graves en détectant les odeurs de code.

La détection des odeurs de code peut sembler intrusive et bruyante au moment du développement, mais elle encourage les développeurs à suivre les normes de codage recommandées et les meilleures pratiques, ce qui contribue à créer une culture de code de haute qualité au sein des équipes de développement.

Ils servent de concepts directeurs aux développeurs qui travaillent sur des projets de refactorisation, en les orientant vers un code plus propre, plus modulaire et plus facile à maintenir.

Par ailleurs, les odeurs de code sont des outils pédagogiques qui aident les développeurs à mieux comprendre les modèles et les concepts de conception logicielle.

Les développeurs peuvent affiner leurs compétences, développer une conscience et une appréciation de la qualité du code, et contribuer à l'amélioration continue de la base de code en identifiant et en corrigeant les odeurs de code.

En donnant aux développeurs un langage commun pour discuter et gérer les problèmes de qualité du code, les odeurs de code favorisent la coopération et la communication.

En détectant et en corrigeant systématiquement les odeurs de code, les projets logiciels peuvent réduire la dette technique, augmenter la maintenabilité à long terme et améliorer la qualité globale des logiciels.

Comment remédier aux code smells ?

La correction des code smells nécessite un plan systématique axé sur la recherche de la source du problème et l'utilisation des techniques de refactorisation appropriées pour y remédier. Les code smells doivent d'abord être classés par ordre de priorité par les développeurs en fonction de leur impact sur la base de code et des avantages potentiels de leur correction.

L'extrait de code ci-dessus a contribué aux code smells car il était inutilement complexe et contenait trop de lignes de code.

Les problèmes qui peuvent contribuer à la complexité cognitive ou, pour le dire simplement, à la « surcharge cérébrale », peuvent amener les développeurs à passer plus de temps à lire et à comprendre le code qu'à l'écrire.

Une complexité cognitive élevée ralentit les changements et augmente le coût de la maintenance.

La refactorisation du code en fonctions plus petites permet de répartir la complexité sur plusieurs fonctions et les ruptures dans le flux ne sont plus imbriquées.

def process_user(user):

    if user.is_active():             # +1 (if)

        process_active_user(user)

    else:                            # +1 (else)

        process_inactive_user(user)

def process_active_user(user):

    if user.has_profile():           # +1 (if) +1 (nested)

        ... # process active user with profile

    else:                            # +1 (else)

        ... # process active user without profile

def process_inactive_user(user):

    if user.has_profile():           # +1 (if) +1 (nested)

        ... # process inactive user with profile

    else:                            # +1 (else)

        ... # process inactive user without profile

Un autre exemple courant de code malodorant est l'utilisation d'une fonction intégrée comme nom de variable. Bien que cela ne soit pas susceptible de se produire chez un développeur expérimenté, il ne s'agit pas d'une bonne pratique de codage, car la fonction intégrée ne sera pas accessible via son nom d'origine si elle est utilisée de cette manière.

 def a_function():

    int = 42

La bonne façon de corriger cela est d'utiliser une variable appropriée:

def a_function():

    value = 42

Un autre exemple tiré de ce qui précède est celui des fichiers contenant trop de lignes de code.

Lorsqu'un fichier source devient trop volumineux, il peut accumuler de nombreuses responsabilités et devenir difficile à comprendre et à maintenir.

Pour rendre le code plus facile à maintenir, les fichiers dépassant un certain seuil doivent être refactorisés en fichiers plus petits dont le code se concentre sur des tâches bien définies.

Ces fichiers plus petits seront plus faciles à comprendre et à tester.

Il existe des milliers de problèmes de ce type qui peuvent entraîner des odeurs de code, et les traiter rapidement favorise les bonnes pratiques de codage.

Dès que les odeurs de code ont été localisées, les développeurs peuvent utiliser diverses stratégies de refactorisation pour s'en débarrasser sans modifier le comportement extérieur du code.

Les développeurs peuvent diviser les procédures longues et compliquées qui entraînent des odeurs de code en méthodes plus petites et plus faciles à gérer, chacune traitant une tâche spécifique.

Code malodorant et refactorisation

La refactorisation, qui consiste à restructurer le code sans modifier son comportement extérieur, est généralement utilisée pour traiter les problèmes de code malodorant dans le but d'améliorer la lisibilité, la modularité et la qualité globale du code.

Le processus de refactorisation comprend une analyse rigoureuse des compromis, car la mise en œuvre précipitée de changements peut entraîner des effets inattendus ou de nouveaux problèmes.

Par conséquent, l'élimination des odeurs de code nécessite une stratégie bien équilibrée qui intègre le savoir-faire technique et la compréhension des objectifs et des limites du projet.

En fin de compte, les équipes logicielles peuvent promouvoir une culture d'amélioration continue en détectant et en corrigeant de manière proactive les odeurs de code, garantissant ainsi que leur base de code

est maintenable, fiable et sécurisée face aux changements à long terme.

La refactorisation doit s'accompagner de tests complets afin de garantir qu'aucun défaut ou régression n'est introduit.

Afin de préserver la lisibilité de la base de code et de faciliter les efforts de maintenance futurs, les développeurs doivent également inclure dans leur documentation la justification de chaque étape de refactorisation.

Le partage des connaissances au sein de l'équipe et la validation des décisions de refactorisation peuvent être facilités par des revues de code et la programmation en binôme.

Sonar et les odeurs de code

SonarQube Server et SonarQube Cloud peuvent aider les développeurs à identifier et à prévenir les odeurs de code ainsi que divers autres problèmes (bogues, vulnérabilités de sécurité, etc.).

Les deux s'intègrent nativement à vos pipelines CI/CD pour détecter et corriger les problèmes dès le début de la phase de développement, avant qu'ils ne créent des difficultés en production.

SonarQube for IDE, un outil complémentaire à SonarQube Server et SonarQube Cloud, est un plugin IDE qui fournit des commentaires en temps réel dans l'éditeur du développeur, en mettant en évidence les problèmes de code (y compris les odeurs de code) au fur et à mesure que les développeurs écrivent le code.