Au fur et à mesure que les projets Web, le nombre de fonctionnalité augmente et l'architecture se dégrade à chaque itération.

Le refactoring consiste à retravailler le code source non pas pour ajouter une fonctionnalité supplémentaire au logiciel mais pour le rendre plus propre, améliorer sa lisibilité et simplifier sa maintenance. Je vais ici donner quelques conseils pour, je l'espère, rendre cette opération, au combien importante, la plus efficace possible.

Vous avez sans doute déjà été confronté à une classe, une méthode ou une fonction devenue trop longue ou trop complexe. Un code source tend inexorablement à devenir de plus en plus complexe au fur et à mesure de son existence. Le refactoring est la pratique qui offre la possibilité de conserver une architecture simple et efficace quelle que soit la taille et l'historique du projet.

Avantages du refactoring

Pratiquer régulièrement le refactoring offre 2 avantages :

• maintenir une structure cohérente et lisible des codes sources
• maîtriser à tout moment l'architecture de votre code, ce qui permet in fine de développer plus proprement

Quand pratiquer le refactoring ?

Sans aucun doute, le meilleur moment pour faire les opérations de refactoring est après le développement d'une fonctionnalité, avant de passer à la fonctionnalité suivante. Le fonctionnel étant posé, c'est le moment idéal. Cela permet de repartir pour la prochaine itération sur des bases solides et un code bien architecturé.

Les différentes niveaux de refactoring

Les opérations de refactoring peuvent se découper en 3 étapes distintes.

Modification de la présentation

Durant cette étape, on va améliorer la lisibilité du code notamment en veillant à ce que les conventions de codages soient bien respecté, on corrigera également les commentateurs qui ne sont pas synchroniser avec le code source.

Modification des algorithmes

Ce type de modification est destiné à conserver des méthodes aussi simples que possible sans altérer la structure. Par exemple, on améliorer certaines conditions, remplacer des passage par valeur par des passage par références, ou retravailler certaines boucles pour en réduire la complexité.

Dans ce type de modification, il est tout à fait possible (et fréquent) d'introduire des bugs, il est donc fortement conseillé de construire une batterie de tests unitaires et de l'exécuter après chaque modification.

Réorganisation de la structure

Dès lors que notre code est plus lisible et que les algorithmes mieux travailler, on peut aisément retravailler la structure de notre code, son architecture. C'est à cette étapes que l'on va externaliser certains algorithmes dans des méthodes voir des classes spécifiques. On pourra retravailler également notre hiérarchie de classe. Notre code n'en sera que plus clair, plus pratique et toutes les modifications futures seront plus simples.

C'est aussi à ce niveau que l'on pourra introduire des design pattern dans notre application.

Le refactoring est certainement l'une des opérations les plus importantes dans le développement d'application Web robuste. Négliger cette phase serait une grave erreur car elle induirait de facto une application complexe très difficile à maintenir. La perte de temps engendré serait bien plus grande que le temps qu'on y aurait consacré.