Les programmeurs débutants doivent-ils être impliqués en tant que réviseurs de code dans les projets des programmeurs chevronnés?

Un des membres de mon équipe, un programmeur junior, possède des compétences impressionnantes en programmation pour son niveau d'expérience.

Et lors de la révision du code, je crois qu’il est important de mettre l’accent sur l’apprentissage, sans signaler les erreurs.

Mais les programmeurs débutants doivent-ils participer à la révision du code pour les programmeurs plus expérimentés? Ou les revues de code devraient-elles être suivies uniquement par des programmeurs ayant l'expérience correspondante?

L'objectif principal d'une révision de code est de rechercher des défauts ou des problèmes potentiels. Les participants à l’examen devraient être les personnes les mieux à même d’identifier ces problèmes, quels que soient leur titre et leur ancienneté.

Par exemple, si une application est en cours de développement en Python et que l’ingénieur débutant a plus d’expérience du langage Python que l’ingénieur principal qui a écrit le code, il peut constituer un atout précieux pour la recherche de méthodes de remplacement, mais peut également avoir moins de connaissances du système dans son ensemble.

Au-delà de l'expérience dans les outils et les technologies, considérons également l'expérience dans le domaine des applications. Une personne ayant 20 ans d’expérience, mais seulement 1 ou 2 dans l’industrie financière peut être aidée par le fait que le développeur soit globalement moins expérimenté et que seulement 5 ans d’expérience, tous dans l’industrie financière examinent 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 dans les révisions de code, 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 pouvant totalement 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 débutants doivent-ils être impliqués en tant que réviseurs de code dans les projets des programmeurs expérimentés?

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 code que pour le mauvais. Bien que l'on puisse espérer que le code d'un développeur senior ne serait pas mauvais ...)

De toute évidence, il n’est pas sage de n’avoir que des juniors pour la révision du code. Et peu judicieux de placer 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 débutants peuvent apporter.

Une autre réponse mentionnait que les juniors étaient / se sentaient intimidés. Ce n'est PAS ce que devrait être l'examen du code ... pour les examinateurs ou les réviseurs. Si cela se produit, votre groupe doit changer la façon dont il procède à la révision du code ... et peut-être que les intimidateurs doivent être mis en file.

J'ajouterais que si un programmeur "junior" ne peut pas comprendre un code pour personnes âgées, c'est en soi une bonne mesure du code. OK, il peut arriver qu'il soit impossible d'écrire du code que tout le monde puisse comprendre, mais heureusement, il s'agit d'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 n’ait pas la tâche de 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 des ressources humaines ) avant de pouvoir participer à la révision.

Comme d'autres l'ont souligné, la révision du code peut être un processus à double sens; cela aide tout le monde à comprendre la base de code, il partage donc les connaissances, il aide les juniors à apprendre de nouvelles et meilleures méthodes et techniques de leurs aînés et aide les seniors à affiner leur compréhension et en écrivant pour que tout le monde puisse suivre le code attraper des erreurs.

Les révisions de code ont pour but de détecter les problèmes impossibles à détecter, tels que les problèmes de maintenabilité et les cas critiques. Je dirais que, à bien des égards, les programmeurs débutants conviennent mieux à 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é de comprendre le code.
• Lorsque vous parlez de maintenabilité du code, vous entendez tout le monde dans l'entreprise, pas seulement vos meilleurs programmeurs. Cela signifie que vos programmeurs débutants doivent être capables de comprendre le code pour pouvoir le déclarer maintenable.
• Ils sont souvent moins enclins à faire de mauvaises hypothèses, convaincus que quelque chose fonctionne de la façon dont ils pensent que cela devrait fonctionner.
• Leur formation 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, une personne âgée peut utiliser accidentellement une habitude qu'il a reprise dans C ++ et qui compile mais fonctionne différemment en Java. Les juniors décèlent plus facilement ce type d’erreurs.
• Les réviseurs de code doivent seulement identifier les problèmes, sans nécessairement proposer une meilleure solution. Ils feront souvent des commentaires dans le sens suivant: "Je ne peux pas vraiment comprendre comment faire mieux, 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 moyens par lesquels les programmeurs expérimentés sont plus aptes à faire des revues, mais ce que je veux dire, c'est que vous ne rendez pas service si vous ne tirez pas pleinement parti de la diversité de votre équipe.

On demande souvent aux juniors de maintenir le code, il est essentiel qu'ils puissent le comprendre.

Parfois, les juniors sont les seules personnes disponibles pour consulter le code des développeurs seniors. Le code doit-il attendre avant de passer à QA (nous n'excluons rien de dev sans une révision de code et je suppose également ce type de révision de code) car le patron de la personne âgée est en vacances?

J'ai aussi spécifiquement demandé aux juniors de réviser le code quand je savais qu'ils feraient bientôt quelque chose de similaire pour un client différent ou si je savais qu'ils avaient travaillé sur quelque chose de similaire ou qu'ils avaient des compétences particulières.

Si le code est assez simple, je demande souvent à un junioriste de faire la révision. 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 éléments les plus faciles. Après tout, vous ne pouvez pas passer le stade junior avant de cesser de vous sentir intimidé.

J'ai souvent constaté que si je devais expliquer le code à une personne junior qui ne le comprenait pas, je verrais une erreur que j'ai commise (généralement dans une hypothèse) et qu'aucun réviseur de code expérimenté ne l'aurait interceptée car le code était exécuté. 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 le trouve. Etant donné que les personnes plus expérimentées ne sont pas souvent guidées pas à pas dans le code, ces types de choses se trouvent plus facilement quand un junior effectue la révision.

Je trouve que le fait d'avoir junior impliqué dans des revues a plusieurs effets positifs. Premièrement, cela les rend plus confiants quand ils peuvent comprendre le code d’une personne âgée. Cela les rend encore plus confiants quand ils peuvent trouver un bogue dans ce code.

Cela les expose à des processus de pensée extérieurs à la leur 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 l'occasion de demander ce que fait le code alors qu'il est encore frais dans l'esprit de l'auteur. C'est beaucoup mieux que d'avoir à entretenir 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 personnes âgées, car les questions exposent à la fois les domaines dans lesquels les jeunes sont faibles et ont besoin de mentorat (afin qu'ils puissent prendre plus de responsabilités et donner plus de temps aux personnes âgées pour effectuer d'autres types de tâches), ou des domaines où le code n'est tout simplement pas clair. n'importe qui sauf l'auteur (ce qui signifie que l'auteur pourrait ne pas l'avoir bien compris dans un an). Cela aide également les seniors à comprendre que les juniors sont peut-être plus intelligents qu'ils ne leur en ont attribué le mérite. Cela aide tout le monde à rester professionnel. Après tout, si vous excluez les juniors, vous impliquez clairement que vous ne pensez pas qu'ils sont capables de comprendre le code qui est psychologiquement malheureux.

Les juniors qui révisent le code des personnes âgées 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 crédité. Les juniors pensent parfois qu'ils ont plus de compétences que les leurs. S'exposer au code qu'ils ne peuvent pas écrire est bon pour ces personnes car elles commencent à se rendre compte qu'elles ont beaucoup plus à apprendre. Cela incitera également les meilleurs à acquérir les compétences. Parfois, à l’école, les étudiants B ne comprennent pas pourquoi ils n’ont pas obtenu un A tant que l’on ne leur a pas montré un échantillon du niveau A du travail. Idem pour les juniors aux seniors en révision de 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 à procéder à une révision efficace du code, le meilleur moyen est de voir comment les seniors le font.
• Un programmeur débutant peut avoir plus d’expérience qu’un senior dans une langue / un domaine / etc.
• En obligeant les juniors à évaluer le code des seniors, ils vont inévitablement apprendre des choses. La programmation en binôme constituera un moyen plus efficace de le faire, car toutes les questions des jeunes 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 revu. 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 aînés ne sont pas égaux. Parfois, il peut ne pas y avoir beaucoup d’écart, alors ne vous attardez pas sur les intitulés des postes.

Contre:

• Il y a un risque que les examens s'enlisent avec des problèmes mineurs des juniors.
• Le niveau de connaissances / compétences requis peut dépasser les capacités du junior. Cela va non seulement leur faire perdre du temps, mais peut-être aussi les démoraliser.

Je crois fermement que tous les membres de l'équipe doivent être impliqués des deux côtés de la révision du code. Les juniors doivent 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 soudainement un meilleur moyen de le faire avant la fin de l'explication. Les révisions de code ont probablement trois objectifs:

1. S'assurer que le code est correct
2. Amenez l'auteur à réfléchir à la manière dont les autres verront leur code
3. Obtenez les commentaires du lecteur sur ce qui pourrait être amélioré et une deuxième paire d'yeux

Je suis un junior et je révise couramment le code écrit senior. Il s’agit d’une politique générale de la compagnie: "Tout le monde passe le code en revue par quelqu'un". J'apprends beaucoup en passant en revue leur code et en ayant l'occasion de poser des questions sur les raisons pour lesquelles les choses sont faites d'une certaine manière. Et parfois, je propose une manière plus propre de faire un certain morceau de code et autres. Bien plus rare que les gens me disent comment améliorer mon code, mais c'est déjà arrivé au moins une fois.

La révision de votre code est également importante. Les nôtres sont très informels et se composent de "hé, regardez mon code" étant dit à travers des cubicles ou dans un canal privé IRC. J'imagine que si vous examiniez le code dans un contexte plus formel, le débutant serait probablement beaucoup plus intéressé par l'examen du code d'un aîné.

Absolument, les ingénieurs débutants devraient examiner le code des ingénieurs seniors, au moins de temps en temps.

D'après mon expérience, il est assez rare que le réviseur lors d'une révision individuelle du code constate effectivement une erreur que le codeur d'origine ignore, que le réviseur soit senior ou junior; le critique n'a même pas besoin d'être humain . En revanche, il est très courant que le codeur original reconnaisse une erreur en essayant d’expliquer le code et que plus le réviseur est novice, plus il est probable qu’elle le soit, en raison de la profondeur de l’explication requise.

À mon avis, certains avantages plus souvent négligés de la révision de code sont peut-être plus importants à long terme que de détecter des erreurs:

• Partager la connaissance de ce qui se passe réellement dans la base de code - "Attends, je pense que Bill avait une classe qui parle de X, nous n'avons pas besoin d'en écrire un nouveau."
• Partage des connaissances sur les bonnes techniques et le style de programmation.

Sous ces deux aspects, un examinateur subalterne a tendance à en tirer davantage profit qu'un autre.

Les programmeurs débutants doivent absolument effectuer des révisions de code pour leurs collègues plus âgés!

Cependant, ils ne devraient pas être le seul critique . Associez-les à un développeur plus expérimenté lors de la révision du code.

Il y a une myriade d'avantages:

• L'auteur sera obligé d'expliquer plus de son code. Parler de votre code est l’ un des meilleurs moyens de résoudre les problèmes qui se posent avec lui, ou de meilleures façons de le faire.

• L'auteur trouvera des faiblesses dans leur code. Le développeur junior est plus susceptible d'être confondu par certains des morceaux les plus avancés. Souvent, ils sont "trop ​​difficiles" 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 une 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 les utilisateurs sont expérimentés avec les révisions de code, plus les révisions de code deviennent rapides et efficaces.

• Le développeur junior aura une connaissance plus approfondie de la base de code. Être égoïste! En tirant tôt les jeunes développeurs, vous pourrez le leur remettre plus tôt.

• Le développeur junior se sentira plus impliqué. Le développeur junior va commencer à voir le code "senior" (et ses collègues) comme moins étranger et moins intimidant. Il s'agit d'un avantage considérable et souvent négligé des revues de code.

• Le junior dev est un regard neuf. Ils ne sont pas aussi endoctrinés que ceux qui travaillent sur la base de code depuis longtemps. Le développeur junior est plus susceptible de signaler différentes manières d'accomplir des choses lorsqu'il pose des questions. Ne négligez pas leurs commentaires plus sauvages sans au moins une certaine considération!

• Les développeurs seniors sont tenus pour responsables. J'ai souvent vu des situations dans lesquelles les développeurs expérimentés ont tendance à passer sous silence le code de chacun (confiance, paresse, etc.). Une paire d'yeux supplémentaire aide à le décourager.

L'inconvénient à prendre en compte est que toutes les parties concernées consacreront beaucoup de temps à la révision du code. Ainsi, cela peut être un peu difficile à vendre à la direction. Les avantages l'emportent toutefois sur le rythme plus lent.

Une révision de code est faite pour réviser le code, pas pour apprendre. Si j'étais un programmeur junior, je serais intimidé de revoir le code de senior.

D'autre part, la lecture du code de la personne âgée est un excellent moyen d'apprendre, à condition que la personne âgée soit disponible pour répondre à toutes les questions.

Deux alternatives pourraient être:

• permettre aux Juniors d'assister aux réunions de révision du code et laisser chaque intervenant être ouvert à certaines discussions d'enseignement / apprentissage
• pratiquer la programmation en binôme