Les programmeurs juniors devraient-ils être impliqués en tant que réviseurs de code dans les projets des programmeurs seniors?
Un des membres de mon équipe, un programmeur junior, possède des compétences en programmation impressionnantes pour son niveau d'expérience.
Et lors des revues de code, je crois qu'il faut mettre l'accent sur l'apprentissage, pas signaler les erreurs.
Mais les programmeurs juniors devraient-ils être impliqués dans les révisions de code pour les programmeurs plus expérimentés? Ou les revues de code ne devraient-elles être suivies que par des programmeurs ayant une expérience correspondante?
Le but principal d'une révision de code est de trouver des défauts ou des problèmes potentiels. Les participants à l'examen devraient être les personnes les mieux placées pour identifier ces problèmes, quels que soient leur titre ou leur ancienneté.
Par exemple, si une application est développée en Python et que l'ingénieur junior a plus d'expérience avec le langage Python que l'ingénieur senior qui a écrit le code, alors ils pourraient être un atout précieux pour indiquer des méthodes alternatives de faire quelque chose, mais ils peuvent également avoir moins de connaissances sur le système dans son ensemble.
Au-delà de l'expérience dans les outils et les technologies, pensez également à l'expérience dans le domaine des applications. Quelqu'un avec 20 ans d'expérience mais seulement 1 ou 2 dans le secteur financier peut être aidé par un développeur global moins expérimenté avec seulement 5 ans d'expérience dans le secteur financier pour revoir son travail.
Inviter des membres du personnel moins expérimentés à observer et à participer autant que possible au processus de révision du code peut également être bénéfique pour leur permettre d'apprendre une base de code, de poser des questions et de savoir ce que l'on attend d'eux non seulement dans les revues de code, mais code qu'ils produisent. Cependant, vous ne voulez probablement pas que trop de personnes soient impliquées (en se concentrant plutôt sur les personnes qui peuvent pleinement soutenir la révision du code et son objectif) dans le processus.
Cela s'applique vraiment à tout type d'examen - exigences, conception, code ...
Les programmeurs juniors devraient-ils être impliqués en tant que réviseurs de code dans les projets des programmeurs seniors?
Oui, ils devraient. C'est une bonne expérience d'apprentissage de lire le code des autres. (Et cela vaut aussi bien pour le bon que pour le mauvais. Bien qu'on puisse espérer que le code d'un développeur senior ne soit pas mauvais ...)
De toute évidence, il n'est pas judicieux de niquement demander aux juniors de faire la révision du code. Et imprudent de mettre des attentes trop élevées sur les juniors en termes de ce qu'ils peuvent trouver. Cependant, vous pourriez également être surpris par les nouvelles idées que les programmeurs juniors peuvent apporter à la table.
Une autre réponse mentionne que les juniors sont/se sentent intimidés. Ce n'est PAS ce que la révision de code devrait être ... pour les révisés ou les réviseurs. Si cela se produit, votre groupe doit changer sa façon de faire ses révisions de code ... et peut-être que les intimidateurs doivent être alignés.
J'ajouterais que si un programmeur "Junior" peut pas comprendre un code senior, alors en soi c'est une bonne mesure du code. OK, il peut y avoir des moments où il n'est tout simplement pas possible d'écrire du code que tout le monde peut comprendre, mais j'espère que ce sont des exceptions - si seulement 1 ou 2 personnes peuvent comprendre le code, que se passe-t-il lorsque ces personnes ne sont pas disponibles et qu'il y a un problème avec il?
Donner aux gens de nouveaux défis les aide à se développer; il se peut aussi que tout le monde ne soit pas fait pour réviser le code, mais il semble dogmatique d'insister sur le fait que quelqu'un a un titre ( déterminé par la politique et les jeux RH ) avant ils peuvent participer à un examen.
Comme d'autres l'ont souligné, la révision du code peut être un processus à double sens; il aide tout le monde à comprendre la base du code, donc partage les connaissances, il aide les juniors à apprendre de nouvelles et meilleures méthodes et techniques de leurs aînés et il aide les aînés à affiner leur compréhension et en écrivant pour s'assurer que tout le monde peut suivre le code, vous avez plus d'yeux qui peuvent attraper des erreurs.
Le but des revues de code est de détecter les problèmes que les tests ne peuvent pas détecter, comme les problèmes de maintenabilité et les cas d'angle. Je dirais qu'à bien des égards, les programmeurs juniors sont mieux adaptés à cette fin:
- Ils ont plus de temps disponible en général.
- Ils sont plus susceptibles de le prendre lentement, ligne par ligne, par nécessité pour comprendre le code.
- Lorsque vous parlez de code pouvant être maintenu, cela signifie pour tout le monde dans l'entreprise, pas seulement pour vos meilleurs programmeurs. Cela signifie que vos programmeurs juniors doivent être en mesure de comprendre le code afin de le déclarer maintenable.
- Ils sont souvent moins susceptibles de faire de mauvaises hypothèses, confiants que quelque chose fonctionne comme ils le supposent.
- Leur éducation dans un langage de programmation est plus récente et moins susceptible d'être confuse avec des années d'expérience dans une autre langue. Par exemple, un senior peut accidentellement utiliser une habitude qu'il a reprise du C++ qui compile mais fonctionne subtilement différemment en Java. Les juniors détectent plus facilement ce genre d'erreurs.
- Les réviseurs de code doivent seulement identifier les problèmes, pas nécessairement proposer une meilleure solution. Ils feront souvent des commentaires dans le sens de "Je ne peux pas vraiment comprendre comment mieux faire, mais cette partie est vraiment déroutante à cause de toutes les répétitions". Un programmeur plus expérimenté peut alors facilement apporter les améliorations même s'il n'a peut-être pas remarqué le problème au début.
Cela ne veut pas dire qu'il n'y a pas d'autres façons pour les programmeurs seniors de mieux faire des revues, mais je veux dire que vous ne rendez pas service si vous ne profitez pas pleinement de la diversité de votre équipe.
Les juniors seront souvent invités à maintenir le code, il est essentiel qu'ils puissent le comprendre.
Parfois, les juniors sont les seules personnes disponibles pour revoir le code des développeurs seniors. Le code devrait-il attendre pour passer au contrôle qualité (nous ne poussons rien du développement sans révision de code et je suppose également ce type de révision de code) parce que le patron de l'aîné est en vacances?
J'ai également spécifiquement demandé aux juniors de réviser le code lorsque je savais qu'ils feraient quelque chose de similaire pour un autre client sous peu ou si je savais qu'ils avaient travaillé sur quelque chose d'autre qui était similaire ou qu'ils avaient un ensemble de compétences particulier.
Si le code est assez simple, je fais souvent réviser une personne junior. Pourquoi perdre le temps de la personne âgée si la personne junior est tout à fait capable de faire le travail? Si les juniors se sentent intimidés en examinant le code des seniors, demandez-leur d'abord de regarder les pièces les plus faciles. Après tout, vous ne pouvez pas dépasser le statut de junior jusqu'à ce que vous ne vous sentiez plus intimidé.
J'ai souvent constaté que si je dois expliquer le code à une personne junior qui ne le comprend pas, je verrai une erreur que j'ai faite (généralement dans une hypothèse) et qu'aucun réviseur de code expérimenté n'aurait détecté parce que le code s'exécute mais ne fait pas exactement ce qui était prévu. Ainsi, le simple fait d'expliquer les choses aidera souvent le développeur à voir un problème sans que le réviseur de code ne le trouve. Étant donné que les personnes plus expérimentées ne sont pas souvent prises en compte étape par étape dans le code, ce type de choses se trouve plus facilement lorsqu'un junior effectue la révision.
Je trouve qu'avoir un junior impliqué dans les revues a plusieurs bons effets. Tout d'abord, cela les rend plus confiants lorsqu'ils peuvent comprendre le code d'une personne âgée. Cela les rend encore plus confiants lorsqu'ils peuvent trouver un bogue dans ce code.
Il les expose à des processus de réflexion en dehors des leurs et leur permet de voir d'autres façons de gérer les choses. Même en tant que personne âgée, cela m'est arrivé - voir une manière différente de résoudre un problème peut ouvrir les yeux sur de nouvelles possibilités.
Cela les aide à apprendre à lire le code des autres et leur donne la possibilité de demander ce que fait le code alors qu'il est encore frais dans l'esprit de l'auteur. C'est bien mieux que d'avoir à maintenir la chose six mois plus tard lorsque l'auteur est parti depuis longtemps ou est occupé sur un autre projet et n'a pas le temps de poser des questions.
C'est bon pour les aînés parce que les questions exposent à la fois les domaines potentiels où le junior est faible et a besoin de mentorat (afin qu'ils puissent prendre plus de responsabilités et donner aux aînés plus de temps pour effectuer d'autres types de tâches) ou les domaines où le code n'est tout simplement pas clair. n'importe qui, sauf l'auteur (ce qui signifie qu'il pourrait même ne pas être clair pour l'auteur dans un an à partir de quand il doit être changé) Cela aide également les aînés à se rendre compte que les juniors pourraient être plus intelligents qu'ils ne leur en ont donné le mérite. Il aide à garder tout le monde sur un pied professionnel. Après tout, si vous excluez les juniors, vous sous-entendez clairement que vous ne pensez pas qu'ils sont capables de comprendre le code, ce qui est psychologiquement malheureux.
Les juniors qui examinent le code des seniors peuvent générer plus de respect professionnel dans votre organisation. Les aînés peuvent se rendre compte qu'ils ont sous-estimé les juniors et les juniors peuvent se rendre compte que les aînés en savent plus qu'ils ne leur en ont cru. Les juniors pensent parfois qu'ils ont des compétences plus importantes qu'eux. Être exposé à du code qu'ils ne peuvent pas écrire est bon pour ces gens car ils commencent à réaliser qu'ils ont beaucoup plus à apprendre. Cela incitera également les meilleurs à acquérir les compétences. À l'école, parfois, les élèves B ne comprennent pas pourquoi ils n'ont pas obtenu de A jusqu'à ce que quelqu'un leur montre un échantillon du niveau de travail A. Idem pour les juniors aux seniors dans la révision du code.
Ma réponse est: Parfois. Cela va varier d'un programmeur à l'autre et d'une tâche à l'autre.
Pour:
- Si vous voulez que ces juniors apprennent à faire une revue de code efficace, alors le meilleur moyen est de voir comment les seniors le font.
- Un programmeur junior peut avoir plus d'expérience qu'un programmeur senior dans une langue/un domaine/etc. particulier.
- En forçant les juniors à évaluer le code des seniors, ils vont inévitablement apprendre des choses. La programmation en binôme sera un moyen plus efficace de le faire, car toutes les questions que le junior peut avoir peuvent obtenir des réponses immédiates.
- Le code de personne n'est sacré et personne n'est si bon que son code ne devrait pas être révisé. Si vous ne le faites pas, qui va revoir le code de vos meilleurs gars?
- Tous les juniors ne sont pas égaux et tous les seniors ne sont pas égaux. Parfois, il peut ne pas y avoir beaucoup d'écart, alors ne vous attardez pas sur les titres d'emploi.
Contre:
- Il y a un risque que les critiques s'enlisent avec les non-problèmes des juniors.
- Le niveau de connaissances/compétences requis pourrait simplement dépasser les capacités du junior. Cela va non seulement leur faire perdre leur temps, mais aussi très probablement les démoraliser.
Je suis fermement convaincu que tout le monde dans l'équipe devrait être impliqué des deux côtés des revues de code. Les juniors devraient revoir le code senior et vice-versa. Pourquoi les deux? Parce qu'en général, il ne s'agit pas seulement de savoir si le code "résout le problème". Je ne peux pas vous dire combien de fois j'ai dû expliquer un morceau de code à quelqu'un et trouver soudain une bien meilleure façon de le faire à la fin de l'explication. Les révisions de code servent probablement 3 objectifs:
- Assurez-vous que le code est correct
- Demandez à l'auteur de réfléchir à la façon dont les autres verront leur code
- Obtenez les commentaires du lecteur sur ce qui pourrait être amélioré et une deuxième paire d'yeux générale
Je suis junior et j'examine couramment le code écrit senior. C'est une politique générale de l'entreprise "tout le code est révisé par quelqu'un". J'apprends beaucoup de ceux-ci en examinant leur code et en ayant l'occasion de poser des questions sur les raisons pour lesquelles les choses se font d'une certaine manière. Et parfois, je propose une façon plus propre de faire un certain morceau de code et autres. Beaucoup plus rare que les gens qui me disent comment améliorer mon code, mais c'est arrivé au moins une fois.
Il importe également de savoir à quel point vos révisions de code sont formelles. Les nôtres sont très informels et se composent de "hé allez-vous regarder mon code" dit à travers des cabines ou dans un canal privé IRC. Je pourrais imaginer si vous révisez le code dans un cadre plus formel, le junior serait probablement beaucoup plus intimidé par la révision du code d'un senior.
Les programmeurs juniors devraient absolument effectuer des révisions de code pour leurs collègues seniors!
Cependant, ils ne devraient pas être le seul critique. Associez-les à un développeur plus expérimenté par revue de code.
Il existe une multitude d'avantages:
L'auteur sera obligé d'expliquer plus de son code. Parler à travers votre code est l'une des meilleures façons pour trouver des problèmes avec elle, ou de meilleures façons de le faire.
L'auteur trouvera des faiblesses dans son code. Le développeur junior est plus susceptible d'être confondu par certains des morceaux les plus avancés. Souvent, ceux-ci sont "trop délicats" pour leur propre bien et pourraient bénéficier d'une simplification.
Le développeur junior apprendra de meilleures pratiques de codage. Les revues de code sont l'occasion d'enseigner par l'exemple.
Le développeur junior sera un réviseur de code plus efficace. La révision de code est difficile. Plus tout le monde est expérimenté avec les revues de code, plus les revues de code deviennent rapides et efficaces.
Le développeur junior aura une connaissance plus approfondie de la base de code. Soyez égoïste! En tirant tôt sur les développeurs juniors, vous pourrez les leur remettre plus tôt.
Le développeur junior se sentira plus impliqué. Le développeur junior commencera à voir le code "senior" (et leurs collègues) comme moins étranger et intimidant. C'est un avantage énorme et souvent ignoré des revues de code.
Le développeur junior est une nouvelle paire d'yeux. Ils ne sont pas aussi endoctrinés que quelqu'un qui a travaillé sur la base de code pendant une longue période de temps . Le développeur junior est plus susceptible d'indiquer différentes façons d'accomplir les choses en posant des questions. Ne pas ignorer leurs commentaires plus sauvages sans au moins un peu de considération !
Les développeurs seniors sont tenus responsables. J'ai souvent vu des situations où les développeurs seniors ont tendance à masquer le code des autres (confiance, paresse, etc.). Un jeu d'yeux supplémentaire aide à le décourager.
L'inconvénient à considérer est que toutes les parties concernées passeront pas mal de temps à effectuer des révisions de code. Ainsi, cela peut être un peu difficile à vendre à la direction. Les avantages l'emportent cependant sur le rythme plus lent.
Absolument, les ingénieurs juniors devraient revoir le code des ingénieurs seniors, au moins une partie du temps.
D'après mon expérience, il est assez rare que le réviseur dans une révision de code en tête-à-tête voit en fait une erreur qui manque au codeur d'origine, qu'il soit senior ou junior; le critique n'a même pas besoin d'être humain . Il est très fréquent, en revanche, que le codeur d'origine reconnaisse une erreur en essayant d'expliquer le code, et plus le réviseur est junior, plus cela est probable, en raison de la profondeur d'explication requise.
À mon avis, certains avantages plus souvent ignorés de la révision du code sont peut-être plus importants à long terme que la détection d'erreurs:
- Partager la connaissance de ce qui se passe réellement dans la base de code - "Attendez, je pense que Bill avait une classe qui fait X, nous n'avons pas besoin d'en écrire une nouvelle."
- Partager la connaissance des bonnes techniques et du style de programmation.
Dans ces deux aspects, un réviseur débutant a tendance à bénéficier davantage qu'un réviseur senior.
Une révision du code est faite pour réviser le code, pas pour l'apprentissage. Si j'étais programmeur junior, je serais intimidé de revoir le code des seniors.
D'un autre côté, la lecture du code de la personne âgée est un excellent moyen d'apprentissage, à condition que la personne âgée soit disponible pour répondre à toutes les questions.
Deux alternatives pourraient être:
- laisser les juniors assister aux réunions de révision du code et laisser chaque préposé être ouvert à des discussions d'enseignement/apprentissage
- pratiquer la programmation en binôme