Revues de code (Code Reviews)
Étant enseignant depuis plus de deux décennies (au moment d'écrire ces
lignes), je me suis trouvé, dans l'exercice de mes fonctions, à lire une vaste
quantité de code... de qualité très variable, bien sûr, du fait que plusieurs
des « autrices » et « auteurs » de programmes que je côtoie
sont des débutantes et des débutants.
Offrant parfois des formations en entreprise et des « classes de maître »,
je suis aussi en mesure de constater que l'expertise en termes d'écriture de
code de qualité varie beaucoup selon les individus et leur vécu. Les causes de
cette disparité sont assurément multifactorielles, et je ne compte pas me lancer
dans une étude sociologique sur le sujet (j'espère que vous me le pardonnerez).
Outre l'expérience, l'un des facteurs qui influence le plus le développement
de la Praxis, de la pratique de
la programmation, est la capacité de poser un regard critique (mais
constructif) sur son propre travail; d'appliquer une forme d'introspection sur
cette projection de la pensée qu'est la programmation (pratique métacognitive
s'il en est une!). Il se trouve que, comme le savent celles et ceux dont la
production comporte une part d'écrit (étudiantes et étudiants, professeures et
professeurs, mais probablement toute autrice ou tout auteur de manière
générale), il devient difficile d'avoir un regard critique et efficace sur son
propre travail : je sais que certains de mes textes sont passés à travers des
dizaines de révisions et de mises à jour... et comportent encore des erreurs,
des coquilles, sans doute en partie parce qu'après avoir vu un texte assez
longtemps, nos yeux ne le voient plus dans le détail.
Le texte devient une abstraction, où l'on voit des mots qui n'y sont pas
parce que notre pensée est convaincue qu'ils y sont. C'est une des (nombreuses!)
raisons pour lesquelles nous avons recours à « d'autres paires
d'yeux » : qu'il s'agisse d'amis, de collègues, d'une éditrice
ou d'un éditeur, etc. ce regard extérieur aide à réduire les risques d'erreurs,
à accroître la qualité du texte, et même à clarifier le propos sur la base d'un
regard neuf et extérieur.
Rôle d'une revue de code
La revue de code, ou Code Review, est une pratique par laquelle,
sur une base régulière, une programmeuse ou un programmeur présente son code
source à des pairs (ou encore à une enseignante ou un enseignant) pour obtenir une rétroaction. Ceci tend à faciliter le
dépistage de bogues (plusieurs têtes valent mieux qu'une).
Cette rétroaction peut viser à :
- Identifier des bogues ou des problèmes potentiels qui auraient pu échapper
aux tests
- Valider le respect des standards de
programmation en vigueur dans le milieu auquel le code est destiné
- Vérifier que les algorithmes utilisés sont suffisamment efficaces pour
résoudre le problème visé, que ce soit en termes de vitesse, en termes de
consommation de ressources, en termes de respect d'exigences spécifiques au
problème, etc.
- S'assurer que le code respecte des exigences d'ordre programmatique :
découpage convenable, esthétique et lisibilité,
nommage, etc.
Je ne prendrai pas position dans ce texte sur ces divers sujets; si vous
souhaitez connaître ma perspective sur ces sujets,vous trouverez sûrement cette
information ailleurs sur h-deb.
L'important est que, si une entreprise (ou, de manière plus large, si le
milieu dans lequel évolue l'autrice ou l'auteur du code) souhaite assurer le
respect de certaines règles (p. ex. : si elle applique un
standard de programmation
particulier), la revue de code est une occasion de s'assurer que le code proposé
n'est pas en contravention de cette attente.
Notez qu'il y a une différence entre s'assurer que des règles sont respectées
et poser un jugement esthétique sur la qualité du code : des aspects comme
« ce nom est-il trop court? Est-il trop long? » peuvent parfois être
régulées objectivement, mais un aspect comme « ce nom est-il clair? Est-il
judicieux? S'intègre-t-il harmonieusement dans le contexte plus général à
l'intérieur duquel il apparaît? » s'y prêtent beaucoup moins.
Forme d'une revue de code
Une revue de code peut prendre plusieurs formes, selon les circonstances et
les besoins. Entre autres :
- Un examen du code produit en l'absence de son autrice ou de son auteur, ce
qui est un modèle qu'on retrouve souvent (mais pas nécessairement) en
enseignement. La rétroaction est alors souvent offerte par écrit, en tout ou en
partie
- Une séance seul à seul avec une experte ou un expert, s'apparentant à du
mentorat
- Une variante possible est un échange avec un pair, dans un mode qui peut
faire partie d'une démarche de programmation par binômes (Pair Programming)
- Une rencontre en groupe (typiquement petit) entre la personne ayant produit
le code et des personnes qu'on estime en mesure de donner une rétroaction
pertinente (il est possible de tenir cette rencontre sans l'autrice ou l'auteur
du code, mais dans ce cas la rétroaction différée représente un ajout de travail
et il y existe un risque
- Une séance à distance, chose vécue plusieurs fois durant la pandémie qui
s'est propagée à partir de 2020
- etc.
La forme à
Volet humain de la revue de code
Perspective de l'autrice ou de l'auteur du code sous examen
Perspective de celles et ceux réalisant la revue de code
Enjeux de la rétroaction
Rétroaction écrite
Rétroaction verbale
À ce sujet :
-
http://docforge.com/wiki/Code_review
- Pourquoi faire des revues de code?
- Mieux vaut une revue de code que des tests, selon Kevin Burke en
2011 : http://kev.inburke.com/kevin/the-best-ways-to-find-bugs-in-your-code/
- Vous avez besoin d'une revue de code, selon Alex Bartlow en
2012 : http://www.shipsolid.com/blog/you-need-a-code-review.html
- Comment faire une revue de code qui donnera des résultats, selon
Peter Sergeant en 2012 : http://www.writemoretests.com/2012/06/code-reviews-that-might-actually-work.html
- Les étapes d'une revue de code, selon Jake Goulding en
2012 : http://jakegoulding.com/blog/2012/07/01/the-stages-of-code-review/
- En 2012, Matt Swanson se questionne à
savoir si les revues de code sont une bonne idée ou non :
http://swanson.github.com/blog/2012/11/04/code-reviews-good-idea-bad-idea.html
- Comparaison des patch reviews et des diff reviews,
texte de 2013 :
https://ocaml.janestreet.com/?q=node/114
- Texte de 2013 par Paul Hinze mettant de
l'avant qu'il faut choisir avec soin les gens qui participeront à une
revue de code :
http://phinze.github.io/2013/12/08/pairing-vs-code-review.html
- Selon Venkat Subramaniam en 2014, les
revues de code sont plus importantes que le TDD :
http://svenpet.com/2014/01/07/better-code-reviews/
- En 2014, Jay Hayes explique la revue de
code en quatre étapes :
http://blog.bignerdranch.com/4504-code-review-four-steps/
- Que devrait-on surveiller dans une revue de code? L'opinion
d'Alexandre Brisebois en 2014 :
http://blogs.msdn.com/b/cdndevs/archive/2014/05/07/what-should-i-be-looking-for-during-code-reviews.aspx
- Comment détruire l'âme d'un individu par une revue de code, texte
ironique d' Erik Dietrich en 2014 :
http://www.daedtech.com/how-to-use-a-code-review-to-execute-someones-soul
- À propos de l'utilité des revues de code, texte de
2014 :
http://ncredinburgh.com/blog/posts/a-code-review-is-more-useful-than-you-think
- Les revues de code qui rendent notre code meilleur, par John Graham-Cumming en
2014 :
http://blog.cloudflare.com/making-code-better-with-reviews
- En 2014,
Eric
Lippert compare les avantages et les inconvénients de l'analyse
(statique) et de la revue de code :
http://ericlippert.com/2014/07/15/analysis-vs-code-review/
- Le Review Board, outil de revue de code proposé par Mozilla
en 2014 :
https://mrcote.info//blog/2014/09/04/review-board-preview/
- Une « pyramide de Maslow » pour les revues de code, par Charles-Axel
Dein en 2015 :
http://blog.d3in.org/post/111338685456/maslows-pyramid-of-code-review
- En 2014, Yaron Minsky propose de rendre
les revues de code moins ennuyantes :
https://blogs.janestreet.com/code-review-that-isnt-boring/
- Une entreprise relate ce qu'elle a appris en faisant des revues de
code dans cet article de 2014 :
https://blog.salsitasoft.com/practical-lessons-in-peer-code-review/
- Rendre plus systématique la pratique de tenir des revues de code, un
texte de Jaime Jorge en 2015 :
http://blog.codacy.com/2015/06/18/6-ways-to-formalize-and-enforce-code-reviews/
- Texte de 2015 par Erik Dietrich portant
sur le volet politique d'une revue de code, et sur des moyens de réduire
cet aspect de la pratique :
http://blog.smartbear.com/code-review/avoiding-the-politics-of-code-review/
- Comment maintenir cette pratique alors que l'équipe de travail croît,
et qu'il en va de même pour le volume de code qu'elle produit? Texte de
Cory Zue en 2016 :
http://www.dimagi.com/blog/scaling-code-review/
- Série d'articles de Vince Panuccio, en 2016,
portant sur la manière d'amener une équipe de travail à adopter la
pratique des revues de code :
- En 2016, Bruce Johnson relate que chez
Google, les revues de code servent à bien plus qu'à la détection des
bogues :
https://blog.fullstory.com/what-we-learned-from-google-code-reviews-arent-just-for-catching-bugs-b125a13aa292
- Une autre point de vue sur le sujet, en 2016 :
http://www.deadalnix.me/2016/06/27/on-code-review/
- Réaliser une revue de code efficace, selon David Beveridge en 2014 :
http://blog.originate.com/blog/2014/09/29/effective-code-reviews/