« Nos demandes de fusion attendent des jours, les relecteurs approuvent sans commentaire et les défauts arrivent quand même en production : faut-il garder la revue de code ? » Derrière ce constat se tient une question de budget : combien de temps d’ingénieur la relecture mérite-t-elle ?
Oui, à une condition : que la revue s’occupe de ce qu’elle est seule à pouvoir voir. La revue de code (code review) consiste à faire relire chaque modification par une autre personne que son auteur avant l’intégration à la base commune, le plus souvent au moyen d’une demande de fusion (pull request ou merge request). Elle détecte des défauts de logique et de conception, maintient un code que l’équipe entière sait lire et diffuse la connaissance du système. Tout ce qu’une machine vérifie mieux (format, règles de style, vulnérabilités connues, non-régression) lui est retiré. Une revue lente et sans effet signale le plus souvent des modifications trop volumineuses et un partage mal fait entre l’outil et le relecteur.
Ce que cherche une revue de code
Le relecteur répond à une série de questions qu’aucun contrôle automatique ne pose :
- la modification fait-elle ce que la demande décrit, ni moins ni davantage ?
- est-elle placée au bon endroit, sans dupliquer une logique qui existe ailleurs ni créer une dépendance de plus ?
- que se passe-t-il aux limites : valeur absente, liste vide, appel qui échoue, exécution simultanée ?
- une personne qui découvre ce code dans un an comprendra-t-elle les noms, le découpage et les choix ?
- les tests ajoutés vérifient-ils le comportement attendu, ou se bornent-ils à exécuter le code ?
- le contrôle d’accès est-il respecté, et aucune donnée sensible ne part-elle dans les journaux ?
- la modification se déploie-t-elle et s’annule-t-elle sans risque : migration de données, configuration, compatibilité avec la version en service ?
La revue a deux effets qui ne tiennent pas à la détection de défauts. Elle évite qu’une partie du système ne soit connue que d’une seule personne. Elle laisse une trace écrite des choix, utile lorsque votre organisation doit démontrer qu’une modification a été vue par deux personnes avant sa mise en production.
Elle n’apporte pas la preuve que le code fonctionne. Cette preuve appartient aux tests, organisés selon la stratégie décrite dans notre page qualité logicielle et tests.
Organiser la revue : taille, délai, rôles
La taille des modifications est le premier réglage. Une modification courte, qui poursuit une seule intention, se lit en entier. Une modification volumineuse reçoit une approbation de principe, parce que personne ne peut la relire sérieusement. Deux habitudes suffisent souvent : découper un développement en étapes intégrables, et séparer un remaniement du code d’un changement de comportement.
Vient ensuite la préparation. L’auteur relit sa propre modification avant de la soumettre. Sa description dit ce qui change, pourquoi, comment il l’a vérifié et ce qu’il a laissé de côté. Il ne sollicite personne tant que les contrôles automatiques ne sont pas passés.
Le délai de première relecture fait l’objet d’un accord d’équipe. Une modification en attente coûte : son auteur a changé de sujet, la base commune a bougé, les conflits s’accumulent. Relire le travail d’un collègue passe donc avant l’ouverture d’un nouveau chantier.
Le relecteur est une personne qui connaît la zone modifiée, et une rotation évite que la relecture ne repose toujours sur les mêmes. Les modules sensibles ont des propriétaires désignés, dont l’accord est requis.
Les commentaires obéissent à une convention. Chaque remarque annonce son poids : point bloquant, suggestion ou simple question. Elle porte sur le code et donne sa raison. Quand un échange écrit s’enlise, une conversation de vive voix le conclut, puis la décision est consignée.
Un désaccord de conception se tranche selon une règle connue : le propriétaire du module, ou l’architecte référent. Pour un changement structurant, la conception se discute avant l’écriture du code. Découvrir en revue qu’il fallait s’y prendre autrement coûte une réécriture.
Ce qui relève de l’outil, ce qui relève du relecteur
| Objet du contrôle | Ce que fait l’outil | Ce qui reste au relecteur |
|---|---|---|
| Format et style | Un formateur et un analyseur de style, tel qu’ESLint, appliquent les conventions | Rien : le sujet sort de la discussion |
| Défauts de programmation courants | L’analyse statique, avec un outil tel que SonarQube, les signale sur tout le code | Écarter les fausses alertes, avec une justification écrite |
| Vulnérabilités | Analyse des dépendances, détection de secrets, analyse de sécurité du code | Les erreurs de logique : contrôle d’accès, règle métier contournable |
| Non-régression | Les tests automatisés s’exécutent à chaque modification | La pertinence des tests ajoutés |
| Conception et lisibilité | Des mesures de complexité, à lire comme un signal | Le jugement : est-ce la solution la plus simple qui réponde au besoin ? |
| Adéquation au besoin | Aucun contrôle | L’examen par le relecteur, avec le responsable de produit en cas de doute |
Une règle pratique découle de ce tableau : un commentaire humain sur un point qu’un outil aurait pu relever appelle une nouvelle règle dans l’outil, pour que la remarque ne revienne plus. Ces contrôles s’exécutent dans la chaîne d’intégration, dont la construction est décrite dans notre page DevOps et platform engineering.
Les assistants de relecture fondés sur l’IA générative se rangent du côté de l’outil. Ils commentent vite, y compris sur la logique, et repèrent des oublis. Ils ne connaissent ni le besoin ni l’histoire du système, et se trompent parfois avec assurance. Leurs remarques sont des propositions : l’approbation reste donnée par une personne nommée.
Les dérives d’une revue mal réglée
L’approbation de complaisance est la plus répandue. Le relecteur valide sans lire, par manque de temps ou parce que la modification est trop grosse. La revue existe dans l’outil et ne contrôle plus rien.
Le péage en est l’inverse : une seule personne doit tout approuver. Les modifications s’empilent devant elle, et l’équipe apprend à attendre plutôt qu’à relire.
Le débat de style occupe les commentaires quand l’outil ne l’a pas réglé. Il use les personnes et détourne l’attention de la conception.
La revue utilisée pour juger les personnes ferme la discussion. Un auteur qui craint le commentaire découpe moins, explique moins et soumet plus tard.
Mesurer la revue sans fausser les comportements
Quelques mesures, suivies à l’échelle de l’équipe, disent si la revue fonctionne :
- le délai entre la soumission et la première relecture ;
- la taille des modifications soumises ;
- la part des modifications approuvées sans aucun commentaire ;
- le nombre d’allers-retours avant intégration ;
- les défauts découverts en production dans du code pourtant relu.
Aucune ne se lit seule. Un délai très court associé à une forte part d’approbations sans commentaire décrit une revue de façade. Un nombre de commentaires par relecteur, transformé en objectif, produit du bruit. Ces mesures ne servent jamais à évaluer une personne.
La revue est aussi le moment où une équipe accepte, en connaissance de cause, un raccourci qu’elle devra reprendre. Le consigner à cet instant est le moyen le plus simple de suivre la dette technique.
Reste une décision, qui revient à l’équipe et à sa direction technique : quelles modifications exigent une relecture avant intégration, lesquelles peuvent être relues après coup, et qui tranche un désaccord. Écrite en une page et révisée à intervalles réguliers, cette règle fixe ce que la revue coûte et ce que vous pouvez en attendre.