Combien de bogues est trop?
Je suis parfois frustrée de mon travail en raison de la perception buggyness de mon code. Mais je pense que je suis à produire plus, et sans doute moins que la plupart des gens. Par exemple je viens de terminer l'élaboration d'un projet qui a pris 3 mois où les testeurs trouvent autour de 10 véritables bugs et probablement 10 autres non-bug changements (ie. puis-je changer la couleur de ce bouton). Je pense que ce n'est pas mauvais après 3 mois de développement, mais d'autres personnes sont en me regardant comme si je viens de vérifier dans la plus grande charge de déchets. Qu'en pensez-vous?
Edit: je vais ajouter un peu plus d'infos.
- Je n'ai pas vérifier tout à la fin. J'ai été vérifier en permanence partout et de faire mes propres tests que j'y suis allée. Évidemment, je l'ai trouvé et corrigé de nombreux bugs que je suis allé.
- Première série de tests par les gens de l'extérieur a été au bout de deux mois. La plupart des bugs ont été dans des domaines que je connaissais avaient des problèmes et n'est pas testé à fond moi-même, mais que le logiciel était encore en "sous-développement"
- Deuxième série de tests a été au bout de 3 mois, et comme la première version étaient dans des domaines que je n'avais pas été approfondie, bien que je ne pense pas que c'est que de nombreuses questions.
- La plupart des bugs ont été dans de jolies parties visibles de l'application, de manière à éventuellement fait qu'aggraver les choses. Ces pièces, bien que visibles, ils n'étaient pas vraiment intégrale ou utilisés souvent par l'utilisateur. En fait, certaines des demandes ont été mis de côté comme non essentiels.
- combien de lignes de code?
Vous devez vous connecter pour publier un commentaire.
Un cheveux dans la soupe est trop nombreux et dans la tête trop peu. Tout dépend de la
Le nombre de "externes" bugs pour un programmeur pour 1'000 lignes de code (KLOC) est une constante. Le chiffre varie de 3 à 4 pour de très bons programmeurs à 10 pour la moyenne des programmeurs pour des "lots".
Cela signifie: Pour chaque tranche de 1000 lignes de code, vous constaterez que de nombreux "bugs" (à partir de la bête faute de frappe dans une chaîne complètement f*** de code dans une méthode désastreuses de conception qui conduit à une réécriture complète).
Noter que nous avons l'habitude de faire beaucoup plus d'erreurs, mais le mieux un programmeur obtient le plus de bugs qu'ils trouvent avant le code des feuilles de leur bureau (d'où "externe" bugs " - > bugs qui d'autres personnes à trouver). Aussi, les bons programmeurs ont tendance à faire quelques désastreux de bugs et plus "idiot" bugs (qui sont faciles à fixer, mais le plus gênant: "comment pourrais-je contrôler ce?").
Fait intéressant, le nombre de bugs est constante à l'égard de la langue, donc de très bonne assembleur programmeurs de faire 4 bugs/KLOC, donc de très bons programmeurs C de faire 4 bugs/KLOC, donc de très bons programmeurs Java faire 4 bugs/KLOC, etc.
Cela signifie que les langues qui ont besoin de moins de lignes de code pour obtenir le résultat souhaité, ont un avantage.
Maintenant à la question "quand il y a trop de bugs?" Prendre du recul. Comme vous développer, vous aurez beaucoup de bugs (la plupart d'entre eux interne). Le produit final aura moins de bugs, car la plupart seront trouvés au cours du développement. Cela signifie que c'est important quand vous regardez. Cela signifie également que le nombre de bugs en soi n'est pas une bonne indication de la "santé".
De déterminer quand votre projet commence à tomber malade, vous devez compter vos bugs en quelque sorte (combien de lignes je vous ai écrit, la façon dont de nombreux bugs, je n'ai pu trouver, combien pourrais-je corriger). C'est beaucoup d'effort et souvent de façon négative ROI. Ces choses sont difficiles à mesurer et il faut du temps pour écrire les bugs que vous trouvez quelque part, et tout cela vous distrait de votre objectif: Écrire du code.
Mon approche est de commencer à écrire plus de tests lorsque plus de bugs germer. Le montant estimé de "buggyness" (ou de l'inquiétude de mon côté) est un bon indicateur de savoir si quelque chose est faux. Donc, si vous sentez que vous créez deux nouveaux bugs avec chaque ligne de code, c'est un signal que quelque chose doit être fait. Si vous écrivez beaucoup de lignes de code et tout se met en place comme par magie, alors pourquoi perdre du temps sur la mesure de la façon dont tout va?
Par l'écriture de tests, je peux garder les bugs et je peux vous assurer qu'elles restent morts.
[MODIFIER] Quelques liens avec des infos où j'ai obtenu mon numéros:
Nous n'avons aucun contexte pour vous juger, donc j'aurais payer beaucoup plus d'attention à ceux qui, dans votre entourage immédiat que nous ici.
Cela dit, je ne pense pas que vous pouvez strictement aller par les chiffres. Si vous avez manqué quelques détails importants d'un client serait immédiatement conscient, je vais être réticents à être sur des projets avec vous. Si vous avez raté dingo fonction-fluage des éléments, c'est plus compréhensible.
L'écriture de logiciels pour les clients dont les activités quotidiennes que vous n'avez aucune idée à ce sujet est un énorme problème. Il se peut que vos collègues de travail ont une intuition de passer du temps avec les clients que vous n'avez pas encore, d'où leur réaction.
Ça dépend vraiment. Firefox a environ 15000 bugs, mais il est considéré comme tout à fait utilisable. D'autre part, je ne voudrais pas avoir un bug dans mon stimulateur cardiaque.
Si vous vérifiez dans votre code qu'après trois mois de travail, alors je pense qu'il y a quelque chose de grave.
Comme pour les projets avec une courte checkin-cycle personnellement, je pense que tous les bug c'est un de trop. Toujours corriger les bugs avant d'écrire du nouveau code (#5 dans le Test De Joël).
Relativement parlant, de 10 bugs dans les 3 mois de code pourrait être très bonne. Si je fait un projet qui a pris 3 mois, je ne serais pas surpris si de 200 bugs pourrait être trouvé en elle.
De plus, cela fait une différence si ils sont gros bugs ou petites, et si elles sont le genre de choses que vous devriez avoir pris lors de l'encodage. Si l'un de ces 10 bugs est un problème majeur qui est assez standard chose à surveiller, alors peut-être que d'autres gens sont plutôt justifiée dans leurs pensées.
Perception de la qualité d'un produit logiciel peut varier considérablement entre le programmeur et l'utilisateur. C'est en partie parce que l'on voit de l'intérieur et de l'autre le voit de l'extérieur.
Si elles sont à en juger seulement par le nombre de bogues rencontrés dans les essais, alors que c'est malheureux, parce qu'il porte peu de corrélation à la façon dont ils apprécient le produit quand ils utilisent effectivement. J'ai vu que le test réel de la qualité. Les asseoir à l'avant du produit, puis voir ce que la réaction est.
Autant que le code est beau de votre point de vue en tant que programmeur, il est regrettable (ou la chance, selon votre point de vue) fait de la vie que le logiciel sera jugé sur l'expérience de l'utilisateur de l'utiliser.
Voir aussi: nombre de WTFs par minute.
Comment inquiet, vous devez être dépend de la nature de bugs qu'ils sont. Comment ils sont graves et comment il est probable que vous devriez avoir repéré avant les testeurs.
Si c'est le cas de la somme de net et de l'impôt totaux sur une facture n'est pas à la correspondance de la brute, alors vous devriez être inquiet. Si c'est une affaire de deux personnes, l'édition de la même facture en même temps provoque quelque chose d'étrange arrive 1 fois sur 5, alors vous pouvez être moins gêné.
Comme un accidenté de la métrique, de trois mois que le projet est de 25 000-50 000 lignes de code, et donc vous devriez vous attendre à trouver une dizaine de bugs par 1000 lignes dans les tests internes, de sorte 100-500 bugs serait typique.
Si votre test de département sont des rapports de 0,2 bugs/1000 lignes pour ce qui sonne comme un effort en solo (quelqu'un a-revue de code, il?), alors soit vous êtes très bon, ou ils ne sont pas être assez approfondie.
Vous pouvez vous référer à la sécurité fonctionnelle des règlements comme ISO26262 (http://en.wikipedia.org/wiki/ISO_26262) ou de la norme CEI 61508.
Parce que cela fait une différence si la conséquence de l'échec/bug est la perte d'une vie humaine – ou que ce soit juste le café est à faire froid.
Ces normes décrivent les méthodes et les situations où ils ont à être prises pour réduire le risque.
Le nombre d'échecs est également liée à la complexité.
(par exemple: http://www.cas.mcmaster.ca/~lawford/documents/SeparatingSafetyAndControl.pdf, ch 4.4)
DFSS (design for six sigma) et axiomatique de la conception sont des concepts d'ingénierie pour réduire les échecs dans les produits.
(ne pas être utilisé comme une excuse) mais les bugs dans le code en gros (non trivial) programmes fait partie du jeu. C'est pourquoi nous avons tester les ministères. Même le meilleur programmeur produit bugs que c'est mathématiquement impossible de prouver qu'un morceau de (non trivial) de logiciels n'ont pas de bugs.
http://amartester.blogspot.com/2007/04/bugs-per-lines-of-code.html
C'est très subjectif: une personne est trivial bug peut être un bloqueur de quelqu'un d'autre, ou même d'une fonction à l'autre. Il se pourrait que les conditions n'étaient pas effacer ou corriger, et qui ont été reprises dans le code et ramassé par les testeurs. La qualité de vos testeurs joue également un rôle, mieux ils sont les plus pertinents défauts qu'ils vont trouver.
Je suis juste un perfectionniste, mais j'ai tendance à aller au-dessus de tout et de tester des choses que je sais utilisé pour le casser (et les choses que je connais l'habitude de travailler) pour s'assurer que mes nouveaux correctifs de code de mon ancien problèmes (et de ne pas "réparer" quelque vieux solutions). J'ai une mauvaise habitude de se raccrocha à la fixation d'un bug au lieu d'ajouter quelque chose j'ai besoin d'ajouter. C'est probablement une bonne chose, mais qui sait?
Je suppose que vous passez au moins 3 mois dans l'écriture et de trouver des bugs, et que votre résultat final après 3 mois de travail de 10 bugs. C'est bien. Je n'aurais pas forcément dire que c'est une bonne ou mauvaise, elle dépend de la façon dont beaucoup de votre 3 mois que vous passez la correction des bugs. Si vous êtes juste de cracher code pour 3 mois et ensuite, de l'archiver, 1) vous faites mal, et 2) c'est assez étonnant. Si, toutefois, vous êtes les dépenses de ces 3 mois de la vérification de votre code et de faire en sorte qu'il travaille, dont je soupçonne que vous êtes, je pourrais suggérer les dépenses de juste un peu plus de temps à les vérifier afin d'éliminer au moins 5 de ces 10 bugs. Si elles sont à l'angle des cas qui se produisent avec juste le mal, rare combinaison d'entrées, alors que c'est un peu pardonnable, mais si ils sont assez commun, vous devriez envisager de prendre un peu plus de temps à les traquer.
Pas dire que vous êtes en train de faire un mauvais travail, mais si tous les 3 mois le reste de votre équipe de a à traquer et corriger de 10 bugs vous présenter pour obtenir les caractéristiques de votre place et fonctionne, je peux les comprendre un peu ennuyé.
Si d'autres perçoivent votre code comme étant buggé, alors il est trop buggé. La Perception est plus importante que la réalité. Il n'a pas d'importance si vous avez seulement eu 1 bug. Pour être perçu comme buggy (même si elle n'était que de 1 bug), ce qui signifierait que vous avez créé quelques-uns assez visible bugs.
Comme quelqu'un d'autre a suggéré, on ne peut pas vraiment dire à votre situation si 10 des bugs, c'est trop parce que nous avons besoin de connaître le type de bugs. Je voudrais vous suggérer de regarder les types de bugs que vous créez pour voir si il y a des similitudes. N'avez-vous pas comprendre les exigences? Y avait-il beaucoup par l'une des erreurs? Les erreurs de logique? etc... Alors évaluer si ces bugs que vous devriez avoir pris. Si oui, trouver un moyen de ne pas injecter de ces types de bugs prochaine fois.
Logique/Mathématique/Traitement des erreurs sont presque toujours des cas que vous avez pris. Exigences et interface erreurs sont plus compréhensibles que les mots signifient des choses différentes pour différentes personnes, peu importe la façon dont détaillé vous les écrire. Toutefois, si vous avez compris ce que l'exigence signifie et avait toujours le bug, alors que la condition d'erreur n'est pas compréhensible.
Quelqu'un a fait remarquer que 3 ou 4 erreurs par kSLOC est dans la moyenne, qui semble élevé trop moi, mais j'ai été sur des projets qui étaient en mauvais état (il est peut-être pas). Toutefois, ces projets n'étaient pas très bons développeurs soit. IMO, si ce n'est pas un obscur erreur ou d'une mauvaise interprétation, puis le bug ne devrait pas figurer dans le code. Si c'est pour que vous ne faites pas bien votre travail. Alors peut-être 10 est de trop, peut-être pas, ça dépend des types d'erreurs que vous créez.
À partir d'un perfectionniste vue, 1 bug est de trop. La pertinence de l'perfectionniste vue est arrive à être très subjective.
Si c'est rétractable code, comme quelques bugs que possible est meilleur, car il permettra d'augmenter les ventes (vous n'avez pas le mot de la bouche en disant son buggy).
En haute-sécurité des applications, zéro bugs est vraiment critique (stimulateurs cardiaques, les équipements hospitaliers, les centrales nucléaires), mais ils ont également tendance à être spécifié avec des langages formels qui vous permettent de bien analyser la conception, avec de longues périodes d'essai et de plus longues périodes de test pour vraiment la destruction de tester votre code.
Dans les applications écrites pour certains clients, la façon dont de nombreux bugs sont-ils vous paient pour les supprimer? Sont-ils de payer pour rapide ou de la qualité? Bogue grave dans une application qui a été prévu, et se précipita à travers la production est juste à attendre.
Aussi, était-ce de 10 bugs alors que les testeurs ont été les tests de pré-production de code? Si oui, alors c'est assez bon (dernier projet, j'ai travaillé, j'ai parfois réussi de 10 bugs en un jour... mais alors fixe tous le lendemain, car ils étaient de petites choses que je n'avais simplement pas entièrement pris en compte :)). Mais bug compte avant que le système ne compte plus (à moins d'une semaine avant la sortie et vous avez des problèmes à respecter les exigences)
Ici est un seul point de comparaison (je serais intéressé de voir les autres): un rapide bug requête me dit que dans mon développeur du travail de cette dernière année, je fixe 107 bugs, et en supposant qu'il y a un accidenté de la correspondance entre ce que j'ai corrigé et ce que j'ai à l'origine l'auteur, c'est peut-être environ 25 bugs créé par trois mois.
Que les gens ont dit, il existe de nombreux facteurs de confusion à la recherche d'un raisonnable/significatifs interepretation de ces données (comment sévères sont les bugs, ce genre de système/produit travaillez-vous, ...), mais je serais intéressé de voir cinq ou dix autres personnes contribuent à leur propre "monde réel des données" juste pour essayer de faire la moyenne des preuves anecdotiques.
Il est difficile de dire combien de bugs, c'est beaucoup. Je pense que les métriques impliquant X punaises par Y les lignes de code sont aussi erronées que toute métrique à l'aide de lignes de code (par exemple: mesure de la productivité).
Mon observation est que les développeurs et les utilisateurs/les gens d'affaires ont des vues très différentes de ce que les bugs veux dire. Pour un développeur, tous les bugs trouvés et corrigés augmente le développeur de la confiance dans le code, puisque vous pouvez voir qu'il est de plus en plus robuste. Pour un utilisateur, chaque bug trouvé (même si elle est fixe) diminue leur confiance.
Il me rappelle un peu mon premier cycle de génie logiciel traitement de l'essai: la réussite d'un test n'est pas celui qui passe, mais qui échoue, car il a détecté un bug, et donc conduire à une amélioration. D'une manière similaire réussie code n'est pas réussi car aucun bug n'a été trouvé, mais parce que les bugs ont été trouvés et corrigés. Si peu/pas de bugs sont trouvés dans un morceau de logiciel, je voudrais simplement supposer qu'il n'a pas été suffisamment testé pour le moment.
Certaines personnes préfèrent ne pas connaître quand ils trouver des bugs dans leur propre code en particulier pour les start-ups avec n de suivi de bogues.
Personnellement, je considère que c'est un comportement positif pour les développeurs de trouver que beaucoup de bugs dans leurs logiciels que possible. Bien sûr, je parle de professionnels et compétents développeurs - il n'est pas utiliser en laissant des bugs dans leurs de gagner des bons points de cette façon. Mais si je reçois 1 bug pour la même quantité de code d'un autre développeur déniche de 10 bugs, je ne voudrais pas regarder vers le bas dans ce développeur, surtout si nous envisageons de "gros" projets
La quantité de bugs est moins importante que la longueur de temps qu'il faut pour les détecter. Plus il faut de temps pour identifier un bug le plus cher il sera de repérer et de corriger, et le plus probable, il sera ce que le correctif pour ce bug qui pourrait casser quelque chose d'autre. Test de début et de Tester souvent (TEATO?) est la meilleure approche.
Une possibilité de classer les bugs est d'utiliser une AMDEC-comme méthode. FMEA (Failure mode and effects analysis) est normalement fait dans la phase de conception, et non après. Mais c'est juste une idée de l'importance des défauts comparables.
Une mesure de la "Important" le défaut est effectivement pourrait être RPN = S x O.
Aucun logiciel n'est exempt de bogues. Le développeur lui-même n'est jamais le meilleur testeur. C'est pourquoi des mesures de garantie de la qualité sont toujours nécessaires. Les testeurs qui blâmer, vous devriez être heureux d'avoir trouvé les défauts avant qu'un client ne. Bien sûr, il est toujours mauvaise programmation ou une mauvaise conception, mais aussi les mauvaises test... Le monde n'est pas parfait, mais nous avons à faire face à toutes ces choses d'une manière appropriée. Même en utilisant le resserrement des processus de développement logiciel si le logiciel que vous développez est utilisé dans le domaine médical ou militaire de l'environnement par exemple. Si tous les outils pour la qualité des logiciels ont été utilisés: la Conception AMDEC, Statique de code de vérification par les pairs, des revues de code, tests unitaires, essai composant, système de tests, ... personne ne doit être blâmé.