Aller au contenu
Cabinet d'expertise en transformation technologique · ARDIANE Group Innover, sécuriser, réussir

Ingénierie

Revue de code : l'organiser pour qu'elle trouve ce qu'aucun outil ne voit

L'essentiel

La revue de code est la relecture d'une modification par une autre personne que son auteur, avant son intégration à la base de code commune. Elle cherche ce que les contrôles automatiques ne voient pas (intention, conception, lisibilité, cas limites) : Management Square explique ici comment l'organiser et comment répartir le travail entre l'outil et le relecteur.

Sommaire de la page

« 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.

Insights

À lire sur le sujet

Tous les insights
La sécurité applicative, question par question, pour une direction qui arbitre

La sécurité applicative réunit les pratiques qui évitent qu'un logiciel soit détourné de son usage, de sa conception à son exploitation. Management Square passe ici en revue les questions qu'une direction pose sur la sécurité de ses applications (périmètre, risques, moment des contrôles, responsabilités, textes applicables, preuves) et ce qu'une réponse vérifiable doit contenir.

Lire l'analyse
Test de charge : à quoi il sert, comment le cadrer et lire ses résultats

Un test de charge soumet une application à un trafic simulé, proche de celui qu'elle devra supporter, pour vérifier qu'elle tient ses objectifs de temps de réponse et de stabilité. Sa conclusion ne vaut que pour les scénarios, l'environnement et les critères d'acceptation retenus : Management Square explique ici comment cadrer une campagne, choisir le bon type de test de performance et lire les résultats.

Lire l'analyse
Forfait ou régie, quel mode d'engagement pour quel projet ?

Au forfait, un prestataire s'engage sur un résultat défini, pour un prix et un délai convenus ; en régie, il met des compétences à disposition, facturées au temps passé, et le client décide des priorités. Management Square compare ici les deux modes sur l'engagement, le pilotage, le partage du risque et la gestion des changements, puis décrit les situations où chacun convient.

Lire l'analyse

FAQ

Questions fréquentes

Une autre question ? Posez-la-nous

À quoi sert une revue de code ?

Une revue de code sert à faire examiner une modification par une personne qui ne l'a pas écrite, avant qu'elle ne rejoigne la base commune. Elle détecte des défauts de logique et de conception que les tests ne révèlent pas, maintient un code que toute l'équipe sait lire et diffuse la connaissance du système. Elle ne prouve pas que le code fonctionne : cette preuve revient aux tests automatisés.

Combien de relecteurs faut-il pour une revue de code ?

Il n'existe pas de nombre universel. Un relecteur qui connaît la zone modifiée suffit pour la plupart des changements. Un second regard se justifie sur les parties sensibles : sécurité, calculs réglementés, interfaces partagées entre équipes. Multiplier les relecteurs dilue la responsabilité, chacun supposant que l'autre a lu attentivement, et allonge le délai d'intégration.

L'analyse statique peut-elle remplacer la revue de code ?

Non, les deux contrôles ne portent pas sur les mêmes objets. L'analyse statique applique des règles connues à tout le code, sans fatigue : style, défauts de programmation courants, vulnérabilités répertoriées. Elle ignore l'intention de la modification, le besoin métier et l'histoire du système. La revue traite ce qui demande un jugement, et gagne en qualité lorsque l'outil la décharge du reste.

Faut-il relire le code produit par un assistant IA ?

Oui, avec la même exigence que pour un code écrit à la main. L'auteur de la modification reste responsable de ce qu'il soumet, quelle que soit la manière dont le code a été produit, et doit pouvoir l'expliquer. Un code généré est souvent plausible et bien présenté, ce qui incite à une lecture rapide : le relecteur vérifie d'abord qu'il répond au besoin et qu'il s'accorde avec le reste du système.

Revue de code ou programmation en binôme : que choisir ?

Les deux pratiques poursuivent le même but par des voies différentes. La programmation en binôme est une relecture continue : deux personnes construisent la solution ensemble, ce qui convient aux sujets difficiles ou à l'accueil d'un nouvel arrivant. La revue de code laisse une trace écrite et s'adapte au travail à distance ou en horaires décalés. Beaucoup d'équipes combinent les deux et allègent la revue des modifications écrites en binôme.

Un projet à faire aboutir ?

Un premier échange suffit pour situer votre enjeu, identifier les bons interlocuteurs et vous dire franchement ce que nous pouvons apporter.