Si les organisations pénalisent les développeurs pour le montant des rapports de défauts déposés contre le code qu'ils ont travaillé?
Les organisations devraient-elles pénaliser les développeurs pour les rapports de défauts déposés contre leurs produits de travail?
J'avais une discussion avec mon ami où il demande si un responsable prenant le nombre de défauts déposés contre un développeur est justifié. Ma prise est non, car les développeurs peuvent introduire des défauts, mais en tenant compte de ceux-ci, peut causer des sentiments négatifs inutiles dans l'esprit du développeur.
Quels sont les problèmes de pénalisation des développeurs basés sur des défauts qu'ils injectent? Votre organisation pénitons-elles aux développeurs pour créer des défauts dans les produits de travail?
On dirait que cela ferait plus de mal que de bien. Ignorer un instant s'il est juste que ce soit juste pour un manager de faire cela, regardons la logistique ...
Problème 1: Tous les bogues sont-ils égaux?
[.____] Developer 1 Introduit un bogue: efface toutes les données client et les malédictions.
[.____] -Developer 2 Introduit deux bugs: les étiquettes de formulaire ne sont pas alignées et que la fonctionnalité de calendrier est éteinte de 1 seconde si un événement est créé qui s'étend sur deux années de saut.
Donc, clairement, le développeur 2 mérite plus de chagrin de leur responsable car ils ont le double du taux de bogues. Bien sûr, non pas, vous proposez donc un système de notation de bogues afin que les développeurs avec des bugs triviaux ne soient pas driards si durs. Mais attendez, si le facteur système dans un modificateur pour un développeur qui fait clairement la même erreur triviale et gaspiller le temps du testeur car ils n'apprennent jamais de leurs erreurs? Peut-être, hmmm. Ceci est compliqué.
Problème 2: Qu'est-ce qui compte comme un bogue?
[.____] gestionnaire - Ce rapport était censé inclure un total de fonctionnement, c'est un bogue pour vous!
[.____] -développeur - Ce n'était pas dans les exigences, c'est une fonctionnalité et non un bug.
Problème 3: Comment gémissez-vous des bugs?
[.____] -Developer - "[Nom du gestionnaire], les testeurs ont déposé 10 bugs contre moi car les vitesses étaient incorrectes sur 10 écrans différents, mais qui étaient tous liés à un seul bogue dans la fonction Getvelocity . Nous avons discuté pendant 3 heures à ce sujet, mais ils ne bougeront pas. Nous aimerions une réunion de Sit Down avec vous pour décider du nombre de bugs qui devraient être déposés. Oh et au fait, il n'y a aucun moyen que nous allons frapper le Code Date limite complète demain. "
Problème 4: Plus SLOC signifie probablement plus de bugs
[.____] Developer 1 Siège sur ses fesses toute la journée, mais parvient à écrire 3 lignes de code sans bug entre les arguments sur Reddit sur la loi sur l'immigration de l'Arizona.
[.____] -Developer 2 Fonctionne dur toute la journée et évite un AI entièrement fonctionnel qui ne tue pas John Connor la première chance que ce soit. "
Donc, évidemment, vous voulez pénaliser le développeur qui fait plus de progrès et/ou prend plus de risques en innovant, non?
Résumé
[ Bug, l'importance d'un bug, etc.? Aucune de ces choses ne bouge votre projet en avant et cela sera un poison pour les équipes qui seront obligées de concurrencer des problèmes qui n'ont aucun impact significatif sur le logiciel actuel créé. Sans parler de ce qu'il fait de la culture de votre employé pour concentrer ces efforts sur la recherche de moyens de veiller à ce que les erreurs de chaque employé soient méticuleusement enregistrées afin qu'elles puissent être renvoyées dans leur visage plus tard.
Inévitablement, vous aurez des développeurs Cajolant des testeurs pour travailler autour de votre système de suivi des bogues et signaler directement des problèmes directement afin qu'ils puissent les réparer sans que cela se déroule dans leur "fichier permanent". Ensuite, vous n'avez même pas de comptabilité précise des bugs ou de ce que les gens travaillent vraiment.
Ensuite, il y a la question de l'impact négatif. C'est pourquoi vous pouvez avoir une très bonne documentation avant de commencer à pénaliser les employés, en particulier financièrement. Et si l'un d'entre eux est une classe protégée (minorités, anciens combattants, femmes, handicapés, etc.), vous feriez mieux d'être triples que quel que soit le système que vous avez mis en place ne discrimine pas l'un d'entre eux basé sur l'adhésion à cette classe (ou que Un juge pourrait être convaincu comme tel), même s'il s'agit d'un effet secondaire inattendu du plan.
En fin de compte, vous ne créez pas d'incitations à créer moins de bugs, ce qui est difficile, mais plutôt de négocier des bugs en minimisant leur importance ou en les blâmant sur quelqu'un d'autre.
version courte Non.
Les programmeurs sont notoires pour optimiser les gestionnaires de récompenser. Si vous récompensez LOB, vous obtenez beaucoup d'espaces pour détacher les lignes de la métrique de code. Si vous essayez de punir par le nombre de bugs, vous commencerez à entrer dans les guerres où les développeurs affirment que X n'est pas leur (le bug est dans le compilateur. ou API ou juste ailleurs) - et le bug déposé contre eux est faux.
Le dernier endroit où j'ai travaillé avait un développeur "en charge" d'un produit. Bien que le "responsable" n'a jamais changé au fil des ans, d'autres travailleraient sur le projet lorsque la charge saisonnière l'a rendue nécessaire. Personne ne pointa des doigts et dit "Vous avez écrit ce bogue!" Au lieu de cela, l'objectif était de réduire les insectes dans les produits.
Les endroits où j'ai travaillé, qui avaient des pénalités pour les insectes avaient également une tension très élevée. Le pointage des doigts a contribué à un environnement hostile qui a conduit au départ des développeurs.
Les développeurs devraient se tenir responsables de la qualité du code qu'ils produisent et ils devraient s'attendre à ce que leur responsable fasse de même. Mais cela ne signifie pas que certains développeurs devraient obtenir un démérité chaque fois qu'un bogue est signalé. Aucun manager dans leur bon esprit ne dirait:
Eh bien, Johnson, vous avez vérifié dans 500 lignes de code la semaine dernière et jusqu'à présent 241 rapports de bogues ont été tracés à ce code.
C'est beaucoup de travail pour déterminer qui à blâmer pour chaque petit défaut et que le nombre de rapports de bugs ne vous indique pas toujours beaucoup de la qualité du code. Mais un bon gestionnaire devrait remarquer des problèmes et trouver des moyens de les réparer. Il ou elle pourrait dire:
Johnson, c'était un stylant d'une checkine la semaine dernière - nous avons reçu des rapports de bugs à trois reprises le taux normal. Nous devons obtenir cet ASAP fixe, alors j'ai demandé à "Eagle-Eye" Ferguson d'aller sur le code avec vous. Je suis sûr que vous pourrez le comprendre et ol 'Eagle-Eye pourrait vous montrer quelques astuces en cours de route.
Chaque développeur devrait s'attendre à ce que le gestionnaire remarque leur performance, y compris la qualité générale de leur code. Les développeurs devraient également s'attendre à ce que leurs collègues remarquent - tout va bien dans le référentiel, après tout. Donc, si vous êtes ce gars avec le nombre élevé de bugs, n'avez pas honte de demander de l'aide. Le reste de l'équipe sait probablement déjà où vous êtes, et si vous faites un effort concerté pour améliorer l'équipe (et le gestionnaire) remarquera également cela.
Donc, Oui , vous devriez être responsable du code que vous écrivez, mais Non , l'Organisation ne devrait pas avoir de politique de pénalisation de développeurs individuels pour des défauts spécifiques ou d'avoir dépassé un certain nombre de rapports de défauts. Cela va simplement encourager les gens à trouver des moyens d'éviter le blâme, comme le pointant des doigts ou d'être si prudent que la productivité tombe. Cela n'aide pas l'effort de développement si les gens ont peur d'accepter la responsabilité de ce qu'ils écrivent. BTW, c'est aussi ne vous aide pas à allumer et à récompenser des corrections de bugs spécifiques . ;-)
Non, ils ne devraient pas. Ce n'est pas le travail manuel et ne crée des bugs intentionnellement. Comment pouvons-nous attendre la productivité d'un triste programmeur horrifié? Les choses devraient être cool autour de lui. En fin de compte se Noone tiré profit de pénaliser. 
Je dis que c'est une mauvaise idée qui fera peu mais créera un environnement de travail hostile.
Je vais même aller jusqu'à dire que tout renforcement négatif En tant que facteur de motivation pour la performance professionnelle créera une main-d'œuvre malheureuse et un chiffre d'affaires élevé. Même de bons développeurs se sentiront stressés de glisser.
Le renforcement négatif est même humiliant pour les enfants et les chiens, pourquoi devriez-vous traiter un professionnel de telle manière?
Au lieu de cela, utilisez des renforts positifs pour les numéros de faible défaut et essayez activement d'aider les membres de votre équipe à lutter. Si cela ne marche pas avec quelqu'un à long terme, laissez-les partir.
Je vais faire de la tendance ici, sortez sur un membre et donnez un membre de retentissement oui!, mais avec une certaine qualification: uniquement pour les développeurs qui sont au moins une écart type pire que leurs pairs.
Permettez-moi de casser cela un peu, car il y a quelques problèmes chargés ici. Le premier est le mot "pairs". Ce n'est certainement pas raison de comparer le travail d'un ancien combattant de 10 ans avec celui d'une nouvelle location de frais d'emploi. Le débutant a moins d'expérience, mais le Pro reçoit des missions plus difficiles.
Le prochain vers le haut est une écart type. Les programmeurs vont historiquement d'une part à une main toute tentative de mesure quantitative de leur travail avec des revendications de jeu les métriques, et de l'autre pratiquer l'art de trouver quotidiennement des moyens de quantifier le logiciel et des mesures de devis sur la manière dont les programmeurs de rockstar sont x fois plus productif que la moyenne. Il y a une vérité évidente des deux côtés.
Ma conviction est que la meilleure des métriques d'utilisation, même simplistes comme des "lignes de code", est d'identifier des stand-out. Vous définissez une limite d'une écart type ou de deux à l'écart de la norme, de sorte que les programmeurs individus ne soient pas en mesure de sortir du peloton. Ne cherchez pas le programmeur supérieur ou inférieur. Tout cela est ici que la plupart du temps, personne n'est identifié et il n'y a donc rien à jouer. Mais de temps en temps, il vous aidera à trouver ce gemme d'un programmeur ou vous dire qui est votre véritable sous-interprète. Et puis tu sais ce que tu fais? rien . Au moins au début. Au lieu de cela, pensez-y comme une intelligence non confirmée. Utilisez les informations pour regarder la personne et regarder pour le confirmer ailleurs.
Si vous avez un programmeur qui vérifie les bugs un ordre de grandeur plus souvent que ses pairs, trouvez d'abord quelque chose pour corroborer sa performance globale puis aller avoir une conversation avec lui. Et la première fois, cela devrait probablement être une conversation.
Mon opinion n'est pas parce que si une organisation pénalise les développeurs pour le montant des bogues déposées à leur encontre, le développeur peut être moins productif afin d'éviter les sanctions en supposant qu'ils soient substantiels. Il peut également y avoir des conflits sur les bugs qui seraient déposés contre un développeur car il peut exister une personne d'AQ prenant une vision libérale de ce qui constitue un bug qui est un autre facteur ici. Bien que l'on puisse essayer d'équilibrer les pénalités, je serais curieux de voir à quel point cela se fait bien réalité.
Mon ancien collègue m'a dit une histoire d'un lieu où cette pratique était appliquée: les développeurs ont été sanctionnés pour chaque bogue trouvé dans leur code et QA a été récompensé pour chaque bogue qu'ils ont découvert. Le résultat était que les développeurs ont simplement cessé de développer un nouveau code parce que c'était le seul moyen de se protéger des sanctions.
Les développeurs ne sont pas naturellement paresseux ou ignorants de ce qui est préférable. À mon avis, il serait plus productif de donner aux développeurs plus précis et de meilleures spécifications avant le lancement du projet.
Définitivement pas.
C'est comme la rétrogradation des médecins parce que certains des patients de là meurent, sans envisager la gravité de la maladie/blessure.
Il y a des projets où des défauts sont juste inévitables. Si vous avez des sponsors de projet avec des besoins conflictuels, les exigences de l'utilisateur en conflit avec des directives de sécurité, malgré les modifications de dernière minute, il y aura des défauts soulevés, peu importe la qualité de votre code.
Il y a aussi le problème pérennial (au moins dans la plupart des grandes organisations) de l'infrastructure qui change autour de vous. Vous codez pour le V1.25 de la base de données sur la v3.8 du système d'exploitation, mais un autre département mises à niveau vers V2.0 et V4.0 juste avant de partir en direct. (Ou déclassement, dans un cas, nous avons codé pour V5.0 J2ee uniquement pour que la mise à niveau annulée et a dû défictorier jusqu'à V4.0 jours avant la publication - il y avait beaucoup de défauts.).
Enfin, nous avons les utilisateurs pragmatiques qui augmentent des défauts au lieu de modifier des demandes car le fardeau bureaucratique est nettement inférieur.
Non, il semble tenter de traiter un symptôme, pas le problème des racines. Au lieu de vous concentrer sur le nombre de bugs dans un morceau de code et qui les ont introduits, pourquoi ne pas se concentrer sur le développement d'un système qui aide à éliminer les bugs en premier lieu?
Des outils tels que les tests unitaires, les tests d'intégration, le développement axé sur les tests, l'analyse de code statique, les critiques de conception et les critiques de code peuvent souvent attraper un bon nombre de bogues avant de ne pas entrer dans la base de code. L'intégration continue aidez également à identifier les problèmes précocement plutôt que plus tard.
BTW, la section logique sur la question de l'OP: Si j'hérite un morceau de code rempli de bugs, devrais-je être pénalisé pour tous les bugs restants si je répare une? Par la proposition originale, depuis que j'ai travaillé sur le code, je suis maintenant responsable des bugs.
Quelle est la motivation pour pénaliser les développeurs pour leurs taux de défaut?
L'objectif est certainement d'essayer de mesurer le qualité du code écrit par le développeur.
Le problème est, qualité est un peu amorphe: il est vraiment difficile à mesurer. En fait, vous ne pouvez pas le mesurer directement, vous devez essayer de le rapprocher en mesurant d'autres choses.
En outre, cueillir un kpi unique - tel que des défauts de # - Résultats dans le jeu du système. Si vous suggérez de pénaliser chaque développeur de 10 $ par défaut, combien de temps pensez-vous que ce serait avant qu'un des développeurs effectue une affaire avec un testeur ... Je vais vous payer 5 $ pour chaque défaut Vous me parlez de cela ne vous connecte pas.
Laissez-les réparer tous les bugs liés à leur code, transmettez-leur les plaintes du service des tests, et ils devraient déjà apprendre que moins de bogues est meilleure pour eux.
Et quand tout va bien, et qu'aucun rapport de bogue n'arrive, un clap sur le dos comme récompense et quelques mots gentils devraient faire le reste.
Je dirais que les compter est une erreur. Il n'y a aucun moyen que vous puissiez grincer quelque chose comme ça à un certain nombre. Toutefois, si un code de développeur particulier semble avoir plus de problèmes que le code similaire écrit par d'autres, et c'est un modèle cohérent, je dirais que le développeur n'est probablement pas aussi bon, toutes les autres choses étant égales. C'est un fait à mettre dans le mélange.
En tout état de cause, j'ai été dans cette affaire depuis des décennies et je ne peux pas dire que j'ai jamais vu un programmeur qui avait un taux de bogue inhabituellement élevé ou inhabituellement faible. J'ai vu des programmeurs qui étaient plus rapides ou plus lents, les programmeurs qui pourraient obtenir des emplois ou qui ont eu des ennuis. J'ai vu des programmeurs qui écrivent naturellement très facile pour comprendre le code, le code très rapide ou le code très confus. Mais je n'ai jamais vu de programmeur avec un taux de bogue atypiquement élevé ou faible. Peut-être que je n'ai rien payé assez près.
Je ne suis pas opposé à cette idée - mais seulement s'il existe un consensus sur les défauts: un groupe désigné de techniciens de haut niveau qui les règne. Les utilisateurs, BA et les gestionnaires ne sont souvent pas qualifiés pour décider de ce qui est un défaut de code - et il est toujours dangereux de mettre quelque chose comme celui-ci sous le contrôle d'un (ou de tout) individu.
Mais je ne pense pas que ce soit vraiment nécessaire - quand un développeur écrit systématiquement un mauvais code, si ses aînés et ses pairs font leur emploi, ce ne sera pas un secret pour longtemps et le développeur subira les conséquences avec un système formel de 'démérite'.
Bien que je ne suis pas d'accord avec la prémisse ...
Cela ne pourrait être possible que si vous avez récompensé le programmeur qui prend des caractéristiques plus stimulantes techniquement - "risque plus élevé, une récompense plus élevée". Sinon, pourquoi un programmeur assumerait-il jamais un travail difficile dans cet environnement, puisqu'un défi technique est un passif (pas une opportunité de récompense).
Je conviens que cela créerait également un environnement très hostile. D'après mon expérience, une quantité importante de défauts sont dus à l'exigence d'ambiguïté ou à un manque d'obligation. Je pense donc que cela pourrait également conduire à ces défauts qui sont explicitement attribués à l'analyste de l'entreprise, à l'ingénieur des systèmes ou au sponsor de projet et ils devraient être soumis à la même pénalité - ce qui ne serait pas une mauvaise chose.