Bienvenue sur Développement Agile

Référence sur le développement logiciel Agile. Nous traitons de conception, de programmation, de pratiques de génie logiciel, d'essais et d'autres sujets connexes.

Leçon de vie

Publié par Jean-Francois Gilbert le lundi 9 mars 2015 à 00:00

Il y a quelques temps, j'ai commencé à travailler sur une preuve de concept relativement complexe. Au départ, je n'avais qu’une vague idée des outils et de l’architecture que j’allais utiliser. Il y avait tellement d'inconnus que je ne savais pas trop par où commencer. 

J'ai donc avancé le projet un peu à tâtons. Je m’efforçais de répondre aux exigences fonctionnelles complexes tout en explorant une plateforme que je connaissais peu. Bref, j'en avais un peu par-dessus la tête. Pour sauver du temps et parce que je croyais tout jeter à la poubelle de toute façon, j'ai commencé à coder sans écrire de tests unitaires. Je vois d’ici vos hochements de tête désapprobateurs. Mais je croyais que les chances que mon code puisse être réutilisé plus tard étaient tellement minces que ça me ralentirait d’écrire des tests tout de suite. Oh, mais quelle erreur !

Au début, je dois avouer que ça allait plutôt bien. J'essayais des choses, je changeais d'idée, j’effaçais le code, j’essayais autre chose. Pas de temps à perdre, je produisais du code à la vitesse grand V ! Étant habitué à programmer presqu'exclusivement en mode TDD, je ressentais quand même un certain malaise. Je n'avais pas mon filet de sûreté habituel et je n’étais pas particulièrement fier du design de mes classes. Mais bon, mon prototype fonctionnait, non ?

A un certain moment j’ai réalisé que globalement, la piste que je suivais depuis plusieurs jours était la bonne. Il y avait bien quelques inconnus ici et là, mais je commençais à avoir entre les mains quelque chose d’intéressant. Or, puisque j'avais codé un peu en cow-boy, le design n'était pas génial et ma solution commençait à être sens dessus dessous. J'ai donc commencé à faire du réusinage pour être capable de mieux me retrouver. C'est à ce moment que des bugs ont commencé à faire surface. Je me suis mis à perdre un temps fou. Les modifications étaient suivies par des séances de débogage dans Visual Studio et je maudissais les dieux de la programmation, mais surtout moi-même. Au lieu d'avancer, je faisais des pas en arrière à chaque fois que je modifiais du code.

Je n'ai eu d'autre choix que de recommencer du début. Mais cette fois, j'ai bâti mon code comme je suis habitué de le faire : en TDD. J’ai quelque fois eu le goût de prendre le code du prototype et le copier dans mes nouvelles classes, mais j'ai presque toujours résisté à la tentation. Bien sûr, j'ai gardé certains concepts mais le fait de recommencer du début a fait émerger un design différent et surtout meilleur.

En bref, soyez plus brillants que moi. Prenez le temps de bien faire les choses dès le début et en bout de ligne vous gagnerez du temps. Je crois qu'on peut se permettre d'expérimenter de nouveaux outils sans faire de tests unitaires exhaustifs. Mais il faut savoir identifier le moment où on a une assez bonne idée de la solution et reprendre les bonnes pratiques de développement.

En terminant, voici quelques billets qui pourraient vous intéresser concernant le TDD et les tests unitaires.

Jusqu'à quel point dois-je tester mon code ?

TDD : comment partir du bon pied ?

Comment rendre vos tests plus propres grâce aux builders ?

 

Vos casseroles sont-elles propres ?

Publié par Jean-Francois Gilbert le dimanche 30 novembre 2014 à 00:00

Source: https://www.flickr.com/photos/nicholassmale

Lors de son son keynote présenté à l'Agile Tour de Québec le 5 novembre dernier, Michael Feathers comparait le code à une cuisine. Avant de préparer de nouveaux plats, il va de soi de nettoyer les ustensiles, poêles et casseroles. Idéalement, on le fait au fur et à mesure qu'on les salie. De cette façon, on n'accumule pas une montagne de vaisselle et la cuisine reste relativement propre en tout temps. 

C'est une analogie intéressante mais le principe n'est pas toujours évident à appliquer dans notre code. Ce n'est pas qu'on ne veuille pas nettoyer au fur et à mesure, mais plutôt qu'on ne réalise pas toujours que le code est sale. L'idée même de code propre ou sale varie d'un programmeur à l'autre. Oui il y a de nombreux livres et articles publiés à ce sujet. Cependant, le pourcentage de développeurs qui ont lû sur le sujet ou qui prennent le temps d'appliquer les bonnes pratiques demeure trop bas. 

Encouragez le réusinage du code et discutez des bienfaits dans votre équipe. Décidez ensemble de ce qui est acceptable et ce qui ne l'est pas, mais visez haut en termes de qualité. Si votre cuisine est sale, peut-être serait-il temps d'y remédier. 

Il y a certainement plus d'une façon de sensibiliser vos collègues à ne pas la salir davantage et à commencer à la nettoyer. Une piste de solution possible serait de créer une "check list" des choses à vérifier une fois que le code est terminé. Avant d'archiver du code, un développeur devrait consulter la liste et s'assurer que le code rencontre les standards de qualité établis par VOTRE équipe. 

Je vous suggère de commencer modestement avec quelques éléments de base en expliquant bien la raison de leur présence sur la liste. Bonifiez-là à mesure que les bonnes pratiques sont ancrées dans les mœurs de votre équipe. 

Alors, dans votre cuisine, les casseroles sont-elles propres ?

  • Plus récents
  • 1
  • Plus anciens

Archive