Qu’est-ce que le refactoring de code ?

Martin Fowler a popularisé cette pratique dans son livre « Refactoring », publié pour la première fois en 1999. Le refactoring de code contribue à éliminer les « odeurs de code », que Martin Fowler définit comme « une indication de surface qui correspond généralement à un problème plus profond dans le système ». Il ajoute que les odeurs de code sont « rapides à repérer ou à renifler » et cite les méthodes longues et les classes contenant uniquement des données et aucun comportement comme cas d’odeurs de code.

Parmi les exemples de refactoring de code, citons la correction des erreurs de formatage, le changement de nom des variables non descriptives, la suppression des fonctions dupliquées ou inutilisées et la décomposition des méthodes longues et volumineuses en blocs plus petits et plus faciles à gérer. Ces modifications minimes qui préservent le comportement sont moins susceptibles de casser le code ou d’introduire des erreurs, mais leur effet progressif peut contribuer à optimiser les performances des logiciels.

Le refactoring peut sembler une tâche simple, mais certaines tactiques peuvent aider les développeurs de logiciels à adopter une approche plus stratégique :

• Abstraction

• Composition

• Fonctionnalités mobiles

• Refactoring rouge-vert

• Simplification

L’abstraction est un concept fondamental de la programmation orientée objet. Elle consiste à généraliser les objets afin que les détails complexes soient masqués et que seules les informations essentielles restent.

Dans le refactoring de code, l’abstraction est généralement mise en œuvre pour les grands codes bases. Il se compose de 2 mécanismes :

• La méthode « extract-up » extrait le code d’une sous-classe et le déplace vers une classe abstraite ou une super-classe dans la hiérarchie. Cela permet de réduire la duplication de code et de mieux réutiliser les fonctions ou les attributs partagés.

 • La méthode push-down permet d’insérer le code d’une classe abstraite ou d’une super-classe vers une sous-classe pour la logique qui n’est pas réutilisable ou qui s’applique uniquement à une sous-classe particulière.

Cette approche modulaire décompose ou divise d’énormes morceaux de code en morceaux plus petits pour les rendre plus simples et plus faciles à gérer. La méthode d’extraction et la méthode en ligne sont 2 approches de la composition :

• L’approche d’extraction prend des parties d’une méthode existante et les déplace dans une nouvelle méthode. Cela peut être fait pour des méthodes volumineuses qui contiennent différentes fonctions, par exemple, afin que chaque fonction puisse avoir sa propre méthode autonome.

• L’approche inline remplace un appel à une méthode par le corps ou le contenu de la méthode elle-même, la méthode étant ensuite supprimée. Cela s’applique généralement aux méthodes n’ayant que quelques lignes de code et appelées par une seule classe, par exemple.

Dans cette technique, les attributs, les méthodes et d’autres fonctionnalités sont déplacés entre les classes pour réduire les dépendances et améliorer la cohérence entre les fonctions d’une classe et entre les classes. Cette redistribution permet d’obtenir une conception plus logique et équilibrée du code existant, ce qui facilite son extension et sa maintenance.

Le refactoring rouge-vert s’inspire du développement piloté par les tests, dans lequel les tests sont écrits avant le code source lui-même. Il s’agit d’une stratégie itérative qui permet de refactoriser et de tester en continu.

Ce processus en 3 étapes se déroule de la façon suivante :

• Pendant la phase rouge, les développeurs écrivent des tests pour valider un comportement ou une fonction logicielle spécifique. Ces tests sont initialement destinés à échouer parce que le code n’a pas encore été créé.

• Dans la phase verte, les programmeurs écrivent le code pour le comportement ou la fonction spécifié(e). Il peut s’agir du code minimal requis pour réussir les tests, car l’objectif est ici la vitesse plus que la qualité.

• Enfin, la phase de refactoring consiste à apporter les améliorations nécessaires pour obtenir un code plus propre, plus clair et plus efficace tout en préservant son comportement et en réussissant tous les tests associés.

L’objectif est de simplifier le code et sa logique associée. Il peut s’agir de réduire le nombre de paramètres d’une méthode, de renommer des variables ou des méthodes trop longues, de combiner des expressions conditionnelles qui aboutissent au même résultat, de découpler des fragments conditionnels complexes ou même d’utiliser le polymorphisme à la place des expressions conditionnelles.

Vous pouvez considérer le refactoring de code comme le nettoyage quotidien d’une pièce de votre habitation pour faciliter et accélérer le nettoyage en fin de semaine. L’objectif du refactoring de code est de réduire la dette technique, qui s’accumule lorsque les programmeurs prennent des raccourcis, comme la duplication de la logique, le non-respect des normes de codage ou l’utilisation de noms de variables peu clairs.

Voici quelques avantages du refactoring de code pour les équipes de développement de logiciels :

    • Diminution de la complexité

    • Maintenabilité améliorée

    • Amélioration de la lisibilité du code

    • Vitesse accrue

Le refactoring peut rendre le code plus simple. Les développeurs sont ainsi plus à même de comprendre les grandes bases de code. Les programmeurs nouvellement embauchés en tirent aussi avantage, car ils peuvent rapidement saisir le fonctionnement interne d’un code qui ne leur est pas familier.

Le refactoring de code pose les bases d’une meilleure maintenance. Un code clair demande moins d’efforts lors du débogage, de l’implémentation d’une nouvelle fonction, de la mise à jour des fonctionnalités existantes ou de la mise à niveau vers les dernières technologies. Comme la maintenance préventive dans le secteur de la fabrication, le refactoring de code permet d’appliquer des correctifs mineurs immédiatement afin d’éviter des bugs importants plus tard.

Lorsque le code est refactorisé, il est plus propre, ce qui le rend plus facile à comprendre et à utiliser. Le code refactorisé donne également une navigation plus fluide, ce qui permet de rationaliser le processus de développement des logiciels.

Le refactoring n’a peut-être pas un impact aussi important que les optimisations de code ciblées sur les performances. Cependant, un code plus simple et moins volumineux contribue toujours à des logiciels plus efficaces et à des temps d’exécution plus rapides.

Le refactoring peut aboutir à un code clair et propre, mais le processus n’est pas sans inconvénients. Voici quelques difficultés que les équipes de développement sont susceptibles de rencontrer lors du refactoring de code :

    • Affectation des développeurs

    • Introduction de bugs

    • Code hérité

    • Dérive des objectifs

    • Contraintes de temps

Les équipes doivent décider qui participera au processus de refactoring du code, et quels seront leurs rôles et leurs responsabilités. Cela peut éloigner les programmeurs du travail fondamental de développement des logiciels, et les petites équipes peuvent ne pas être en mesure de se permettre cet aménagement.

Le moindre changement de code comporte la possibilité de créer un nouveau bug ou de faire remonter un bug existant. Un refactoring de code plus complexe peut également casser ou modifier des caractéristiques et des fonctions.

Le code hérité fait référence aux anciennes bases de code qui servent toujours leur objectif, mais qui ont été développées à l’aide de technologies désormais obsolètes et qui ne sont plus activement prises en charge ou gérées. Cela peut poser des problèmes de dépendance et de compatibilité lors du refactoring. Une analyse plus approfondie du code et un plan détaillé sont alors nécessaires pour traiter les changements qui affectent le code hérité.

Il peut être tentant de corriger plus que nécessaire, surtout lorsqu’aucun plan n’est en place ou qu’aucun objectif clair n’a été fixé. En ce qui concerne la restructuration logique en particulier, le champ d’application peut s’étendre lorsque les programmeurs n’ont pas pris le temps d’examiner le code et de déterminer quelles parties peuvent être affinées.

Le refactoring de code peut prendre beaucoup de temps, ce qui manque à la plupart des équipes de développement. Ils doivent trouver un équilibre entre le besoin de refactoring et le respect des délais du projet, et déterminer quand et dans quelle mesure le remanier.

Avant de vous lancer dans le refactoring de code, suivez les conseils ci-après pour vous aider à relever les défis du processus :

    • Le timing est important

    • La planification est essentielle

    • Analyser et normaliser

    • Tester et documenter

Le moment où il faut refactoriser le code est aussi important que le pourquoi ou la manière de le faire. Le refactoring peut faire partie des activités de maintenance périodiques d’une équipe de développement de logiciels ou être intégré aux vérifications du code.

Le refactoring est également indispensable avant l’ajout de nouvelles fonctionnalités, l’implémentation de mises à jour majeures, le passage à des piles technologiques plus récentes ou la mise à niveau des interfaces de programmation des applications (API) ou des bibliothèques. Il permet de créer un cadre des exigences plus évolutif et adaptable sur lequel s’appuyer à l’avenir.

La refactorisation de code peut prendre du temps, ce qui rend la planification essentielle. Les équipes de développement doivent tenir compte des objectifs et de la portée du projet. Elles peuvent aller pas à pas, en consacrant quelques jours à de petits changements tels que la suppression du code mort, la correction du formatage ou la suppression des doublons. S’il s’agit d’un nettoyage plus complexe, la refactorisation devient un projet avec des délais et un calendrier plus long.

Les tâches de refactoring simples nécessitent généralement peu d’analyse. Cependant, pour les techniques qui touchent à la logique, il est essentiel de comprendre l’ensemble du code associé. Déterminer la raison d’être de la structure du code peut aider les programmeurs à prendre des décisions plus éclairées et à apporter des modifications intentionnelles.

En outre, le respect des normes de codage et des principes de conception permet à l’équipe de préserver l’intégrité de la base de code et d’en maintenir l’architecture.

Le refactoring ne consiste pas seulement à améliorer le code, mais également à s’assurer que ces améliorations fonctionnent. C’est pourquoi les tests sont importants pour confirmer que le logiciel lui-même et son comportement restent intacts.

Les développeurs peuvent effectuer leurs propres tests d’intégration et tests unitaires, mais l’équipe d’assurance qualité doit absolument être intégrée au processus. Ils peuvent effectuer des tests fonctionnels pour vérifier les fonctionnalités, et des tests de régression pour vérifier que le code remanié n’introduit aucun bug et n’interrompt aucune fonction.

La documentation des modifications doit également faire partie du processus. Le suivi des modifications est ainsi plus facile, de même que le refactoring du code à l’avenir.

Plusieurs outils peuvent aider à accélérer et à automatiser le refactoring de code. Voici les plus populaires :

    • Environnements de développement intégrés (IDE)

    • Analyseurs statiques de code

    • Autres ressources

De nombreux IDE d’aujourd’hui intègrent la prise en charge du refactoring automatisé sans casser le code ni introduire de bugs. Certains fournissent même des recommandations de refactoring pilotées par l’IA.

Les IDE qui peuvent être utilisés pour le refactoring de code comprennent IntelliJ IDEA pour les langages de programmation basés sur la machine virtuelle Java (JVM), PyCharm pour Python et l’extension ReSharper Visual Studio pour C#, C++ et .NET.

Les analyseurs statiques évaluent le code sans l’exécuter. Ces analyseurs détectent les failles de programmation courantes et les problèmes de qualité du code, ce qui permet aux développeurs de les corriger dès le début du processus de développement logiciel.

Parmi les analyseurs de code statiques, citons Codacy et le PMD open source, qui prennent tous deux en charge plusieurs langages de programmation, JArchitect pour Java, NDepend pour .NET et le linter et le formateur RuboCop pour Ruby.

Refactoring.com est le site Web de Martin Fowler qui présente un catalogue en ligne des méthodes de refactoring tirées de son livre. Refactoring.Guru est un autre site Web qui aborde les techniques de refactoring et les modèles de conception.

L’intelligence artificielle (IA) peut assister le processus de refactoring de code. Les applications d’IA générative sont alimentées par de grands modèles de langage (LLM) qui peuvent analyser des bases de code complexes ou volumineuses et comprendre la sémantique et le contexte sous-jacents. Sur cette base, elles fournissent rapidement des recommandations de refactoring en temps réel.

IBM watsonx Code Assistant, par exemple, exploite les modèles IBM Granite pour identifier les bugs et les domaines à améliorer. Il suggère ensuite des corrections ciblées qui s’alignent sur les conventions de codage établies par l’équipe, ce qui permet de simplifier et d’accélérer le refactoring du code. Parmi les autres outils similaires de refactoring assisté par l’IA, citons Amazon CodeGuru Reviewer, GitHub Copilot et ChatGPT d’OpenAI.

Pour ceux qui travaillent sur un code hérité, IBM watsonx Code Assistant for Z allie IA générative et automatisation pour aider les développeurs à moderniser leurs applications. L’assistant de refactoring de watsonx Code Assistant for Z permet aux programmeurs de restructurer leur application en services plus modulaires et réutilisables. Il utilise des algorithmes d’analyse de code pour moderniser les applications COBOL.

Comme pour tout système d’IA, les développeurs doivent toujours vérifier l’exactitude des résultats des outils de refactoring de code pilotés par l’IA. Des tests sont également nécessaires pour s’assurer que les changements proposés fonctionnent comme prévu.