De geek à directeur technique

J'ai déjà parlé plusieurs fois de l'entreprise 37signals, de ses logiciels de gestion de documentation et de projet, et de sa méthode Getting Real. Actuellement, ses membres travaillent au successeur de leur livre, dont le nom sera Rework. Ils ont présenté quelques bribes d'information sur le livre, et je me suis arrêté sur le quatrième de couverture :

Je trouve que le texte qui s'y trouve est très intéressant, un brin controverse, et mérite qu'on s'y attarde. Voici une traduction très libre de son contenu, et ce que j'en pense.

“Dès que possible” est un poison

Il est vrai qu'en entreprise, on rencontre bien souvent ce genre de situation : On essaye de se mettre d'accord sur la spécification d'une nouvelle fonctionnalité, et quand vient le moment d'en définir la date de livraison, on se voit répondre “Dès que possible”. Cela peut sembler la réponse la plus honnête, la plus simple à comprendre de tous et la plus facile à gérer ; mais en fait il s'agit souvent d'un pis-aller qui démontre que le projet n'est pas réellement pris en main.

Quand on demande un développement ASAP (as soon as possible), on abdique sur tous les facteurs qui définissent un projet :

• La définition exacte du projet n'a pas été faite correctement. On sait bien qu'on n'a pas pris le temps de réfléchir à tous les cas limites, à penser à toutes les situations. On sait − mais on ne le dit pas ouvertement − que les développeurs devront affronter tous ces culs-de-sac fonctionnels au fur et à mesure qu'ils se casseront les dents dessus, ce qui empêche d'apporter une quelconque valeur aux estimations qu'ils peuvent faire de leurs développements.
• À partir du moment où la seule contrainte exprimée est celle du temps passé sur le projet, on accepte implicitement que des raccourcis soient fait pour atteindre l'objectif au plus vite. Un aspect en pâtira forcément, qu'il s'agisse de la qualité générale de la réalisation, de la maintenabilité du code, des tests, du débuggage, ...
• À l'inverse, l'absence de deadline réaliste autorise les développeurs à se lancer dans des développements inutiles (je ne parle même pas de ceux qui se tournent les pouces). On arrive ainsi à des situations où on découvre au bout de 2 semaines que le développement “ASAP” aurait pu durer 4 jours si on avait pris le temps de dimensionner et budgéter le projet correctement ; mais si on en fait la remarque au(x) développeur(s), on obtient une réponse du genre «Ah, moi j'estime que tout ce que j'ai fait était nécessaire pour que le projet fonctionne correctement. Il fallait me prévenir si c'était plus urgent que ça !».

La refactorisation est un exercice qui devrait être maîtrisé par tous les développeurs, encadré par tous les chefs de projets et encouragé par tous les directeurs techniques.

Le refactoring, qu'est-ce que c'est ?

Derrière cet affreux anglicisme se cache le fait de réécrire du code qui a déjà été développé. Le but n'est donc pas d'ajouter de nouvelles fonctionnalités, mais plutôt d'assurer un suivi de l'existant, de faire un ménage qui en facilitera la maintenance.

Nous nous sommes tous retrouvés un jour ou l'autre devant des bouts de code sans queue ni tête, manifestement écrits à la va-vite, ne respectant aucune norme, avec une documentation périmée, sans commentaire, ou truffés de code mort. À chaque fois, nous sommes horrifiés. Dans le meilleur des cas, on se souvient des raisons historiques qui ont conduit à cela (« Ah oui, ça date du projet X, qu'on avait dû faire à toute vitesse il y a 2 ans ») ; dans le pire des cas, on va retrouver le responsable de cette horreur pour lui passer un savon.

Mais la bonne attitude, c'est d'organiser l'amélioration de ce code. Il faut garder en tête qu'on ne travaille pas continuellement sur les mêmes fichiers. Ce qu'on est en train de développer un jour sera utilisé pendant des mois voire des années sans qu'on revienne dessus. Mais au fil du temps, le code ancien devient « friable » : chaque correction de bug devient plus délicate et sujette aux bugs de régression ; chaque ajout de fonctionnalité prend de plus en plus de temps et devient plus difficile.

Je vais faire un parallèle avec la construction immobilière. Quand on construit une maison, on commence par faire les fondations, puis on monte les murs extérieurs, puis le toit et enfin les cloisons intérieures. Quand on développe un logiciel, c'est un peu la même chose ; chaque développement, chaque ajout de fonctionnalité, s'appuie sur des objets ou des librairies qui doivent rester fiables dans le temps. Il faut donc pouvoir revenir à tout moment sur n'importe quel bout de code, accéder à sa documentation, lui ajouter de nouvelles capacités, voire résoudre des bugs qui ne s'étaient encore jamais déclarés.
Parce que le jour où vous faites tomber des cloisons, vous ne devez pas devoir refaire les murs extérieurs ; et si vous ajoutez une étage à votre maison, vous devez pouvoir faire confiance à la chape de béton de vos fondations.

Comment s'y prendre

On peut découper un refactoring en 4 étapes précises. Les trois premières sont importantes et nécessaires, alors que la dernière est à mettre en oeuvre si le besoin s'en fait sentir uniquement.