Est-il bon de revoir des programmes avec les aînés et le patron, même si cela fonctionne bien?
Dans ma société, avant la livraison de tout projet, mon patron demande à mes aînés de passer en revue les programmes écrits par moi ou par d'autres membres de l'équipe ou parfois que le patron se trouve également avec nous pour examen.
Je pense que c'est un bon moyen d'obtenir une connaissance, mais parfois lorsque des programmes fonctionnent bien, ils ne fonctionnent pas même après la révision et je dois regarder à nouveau dans mon programme.
Ils indiquent que cet examen contribue à optimiser l'exécution du programme et de la requête, mais pouvons-nous préférer l'optimisation sur le fonctionnement réel du programme?
"Travailler bien" est en effet une excellente métrique, mais si vous êtes le seul de l'équipe capable de déchiffrer ce que vous avez écrit, et ainsi le maintenir, le code est proche de la valeur sans valeur pour la société pour la moyenne ou à long terme.
Un bon code est au moins:
- travailler comme prévue
- lisible par l'homme/clair
- facilement maintenu
- facilement extensible pour les changements futurs
- en sécurité
- sans dépendances inutiles
- manipulation des cas correctement non nominaux
- etc
(Certaines de ces exigences se chevauchent réellement mais sont bonnes à considérer individuellement ...)
Les revues de code servent le but au-delà de la partie "Travailler", qui peut être faite par des tests automatiques.
Personnellement, je sais que cela est agaçant d'avoir quelque chose à être déchiré et d'avoir à la reconstruire de la terre. Mais, souvent, cela est dû à une mauvaise communication du plomb senior/technique. Donc, si vous pensez que vous devez réécrire trop souvent, la prochaine fois, allez à l'examinateur avant d'écrire une ligne unique et d'essayer d'obtenir autant d'informations que possible sur ce qu'il attend, dans tous les détails. Cela pourrait également être excellent si l'équipe des examinateurs de code résumait leurs attentes dans un document formel que chaque Dev puisse faire référence.
De manière plus positive, une session pourrait également être une occasion de partager d'excellentes pratiques/conceptions.
J'ai interprété votre question comme "Mon code de fonctionnement peut-il être bouché dans un point de vue à un point où il ne compilait même plus?" .
Oui il peut. Généralement, lors d'un examen que vous regardez Comment Votre code fait ce qu'il fait. Lorsque vous souhaitez remettre votre code dans votre code, vous dites que vous avez terminé une certaine partie du programme.
Vous dites que ça fonctionne. Le test est alors terminé pour vérifier cela. Un module de passage des tests ne signifie pas que le module ne doit plus être touché.
Un module apparaissant fonctionnant peut toujours être une catastrophe en attente de se produire, soit au moment de l'exécution, soit dans quelques mois lorsque vous ou quelqu'un d'autre doit effectuer une maintenance dessus. En modifiant votre code dans un examen et en soulignant ce qui n'allait pas avec cela, votre critique est (espérons-le) essayer de vous enseigner quelque chose.
Les examens par des pairs sont sans doute un excellent moyen d'apprendre. Quelqu'un peut voir quelque chose de différent, ils ont une expérience différente pour vous et devraient pouvoir contribuer à apporter des améliorations. Cela ne devrait pas être déprécié, je m'attendrais à ce que tout développeur puisse commenter et critiquer de manière constructive du code de quiconque!
Cela me semble que certaines de ces "améliorations" font des changements de rupture parce que (comme vous l'attendez), le développeur de révision a moins d'expérience avec le logiciel que l'auteur.
Cette tendance est que ce code est-il difficile de suivre ou de maintenir votre code? Vos évaluations sont-elles précieuses? Absolument! Je peux voir comment cela peut être frustrant, d'avoir du code de travail que vos pairs apparaissent alors de casser, vous ne devriez pas être décourageé - vous devriez travailler pour protéger votre code contre ces changements.
La question devient alors comment protéger la fonctionnalité de vos programmes afin que vous sachiez que la fonctionnalité fonctionne toujours après avoir terminé vos critiques. Ma suggestion serait de vous assurer que vous avez une couverture de test unitaire décent. Ainsi, chaque fois que vous/votre critique/votre successeur modifie le code qu'ils peuvent être convaincus que les modifications qu'ils ont apportées sont sûres.
ETA: Je viens de voir l'un de vos commentaires, je suis sûr que cela va sans dire que des critiques de codes devraient être effectuées avant que l'équipe de test ne s'acquitte de ses mains. Sinon, ils ne testent pas le produit final.