it-swarm-fr.com

Quelle quantité de temps devrait être dépensée sur les bugs vs développement original?

Cette question est un peu abstrait mais j'espère que quelqu'un peut me signaler dans la bonne direction.

Ma question est que la quantité de temps peut-on s'attendre à consacrer aux bugs d'un projet de logiciel par rapport au temps de développement initial. Je me rends compte qu'il y a un grand nombre de facteurs déterminants qui vont dans mais j'espérais une panne typique ou moyenne.

Par exemple, si le projet A prend 40 heures à compléter et 10 bugs de fixation supplémentaires, ce projet aurait un ratio 4: 1.

Si un autre projet (B) prend 10 heures à compléter, mais 8 autres sur des bogues, il aurait un ratio 5: 4.

Est-ce un concept documenté/recherché?

METTRE À JOUR

Merci pour toutes les réponses informatives. Je comprends qu'il est impossible de mettre une norme à ce type de métrique en raison de toutes les variables et facteurs environnementaux impliqués. Avant d'affecter une réponse, j'aimerais savoir si cette métrique a un nom convenu afin que je puisse faire de nouvelles recherches. Je voudrais aller à un point où je peux comprendre les mesures nécessaires pour générer les métriques moi-même et proposer une norme de référence pour mon projet.

26
Mike B

Le pourcentage d'équilibre de la capacité totale allouée à la fixation de défauts est égal au Débit d'injection de défaut.

De nombreux facteurs peuvent affecter ce taux, parmi eux, bien sûr: quel type de produit l'équipe développe, quelles technologies et pratiques techniques qu'ils utilisent, le niveau de compétence de l'équipe, la culture de la société, etc.

Compte tenu de l'équipe B, s'ils créent en moyenne 8 unités de retravailler pour toutes les 10 unités de travail, ils travaillent, alors que ces 8 unités créeront de nouvelles unités de reprise de 6,4. Nous pouvons estimer l'effort total qu'ils devront éventuellement dépenser en tant que somme d'une progression géométrique:

10 + 8 + 6,4 + 5,12 + ...

Le nombre de bugs diminuera de manière exponentielle avec le temps, mais l'équipe B a un tel coefficient dans leur exposant qu'il ira à zéro très lentement. En fait, la somme des trois premiers termes de la série ci-dessus n'est que 24.4; des cinq premiers, 33.6; des 10 premiers, 45; de toute la série, 50. Donc, Team B Sommaire: Taux d'injection de défaut, 0,8; Développement de fonctionnalités, 10/50 = 20%; Fixation défectueuse, 80%. 20/80 est leur allocation de capacité durable.

En revanche, l'équipe A est de bien meilleure forme. Leur progression ressemble à ceci:

40 + 10 + 2,5 + 0,625 + ...

La somme de cette série est de 53 1/3, de sorte que l'allocation de développement de fonctionnalités de l'équipe A est de 40/(53 1/3) = 75% et une allocation de fixation défectueuse est de 25%, ce qui correspond à leur taux d'injection de défaut de 10/40 = 0,25 .

En fait, toutes les termes de la série de l'équipe A après les trois premiers sont négligemment petites. Ce que cela signifie de manière pratique, c'est que l'équipe A peut probablement écraser tous leurs bugs avec quelques sorties de maintenance, la deuxième version étant assez faible. Cela crée également une illusion que Any équipe peut le faire. Mais pas l'équipe B.

J'ai pensé à cette équivalence en lisant nouveau livre de David Anderson, "Kanban" . (Le livre est sur un sujet différent, mais répond également aux préoccupations de la qualité.) Lorsque vous discutez de la qualité du logiciel, des citations d'Anderson ce livre, par CAPERS JONES, "Évaluations logicielles, points de repère et meilleures pratiques" :

"... En 2000 ... Qualité des logiciels mesurés pour les équipes nord-américaines ... allait à partir de 6 défauts par fonction point à moins de 3 points de fonction, une gamme de 200 à 1. (# ++ le MidoutPoint est d'environ 1 défaut par points de fonctionnement de 0,6 à 1,0. Cela implique qu'il est courant que les équipes consacrent plus de 90% de leurs efforts de fixation des défauts. "Il cite un exemple fourni par l'un de ses collègues de une entreprise qui dépense 90% du temps fixant leurs bugs.

La fluidité avec laquelle Anderson passe du taux d'injection de défaute à la capacité de la capacité de fixation de défauge (Demande de défaillance Le terme est le terme "suggère que l'équivalence des deux choses est bien connue de la qualité logicielle chercheurs et a probablement été connu depuis quelque temps.

Les mots clés de la ligne de raisonnement que j'essaye de présenter ici sont "équugité" et "durable". Si nous retirons la durabilité, il y a un moyen évident de tricher ces chiffres: vous effectuez le codage initial, puis passez au code quelque part ailleurs et laissez la maintenance à d'autres. Ou vous rencontrez la dette technique et déchargez-la sur un nouveau propriétaire.

Évidemment, aucune allocation particulière ne conviendra à toutes les équipes. Si nous avons décrété que 20% doivent être dépensés sur des bugs, si une équipe a un taux d'injection ultra-basse défaut, ils n'auront tout simplement pas assez de bugs pour remplir le temps et si une équipe avait un taux très élevé, leurs bugs continuera à s'accumuler.

Les mathématiques que j'ai utilisées ici sont de façon simplifiée. J'ai négligé des choses comme des coûts de transaction (réunions de planification et d'estimation, post-mortems, etc.), ce qui affecterait quelque peu les pourcentages. J'ai également omis des équations simulant un produit soutenant un produit et développer une autre simultanément. Mais la conclusion se tient toujours. Faites ce que vous pouvez, en termes de pratiques techniques, telles que le test unitaire, l'intégration continue, les critiques de code, etc., afin de réduire votre taux d'injection de défaut et, par conséquent, votre demande de défaillance. Si vous ne pouvez créer qu'un seul bogue pour 10 fonctionnalités, vous aurez beaucoup de temps libre pour développer de nouvelles fonctionnalités et satisfaire vos clients.

16
azheglov

Malheureusement, je crois que ce rapport est très variable dans un projet donné. Il sera considérablement affecté par votre environnement, votre langue, vos outils, votre taille d'équipe et votre expérience.

8
Mike Clark

Vous devriez passer du temps sur un bogue uniquement si ce que vous gagnez du correctif est plus important de ce que vous investissez.

Utilisez une matrice comme ci-dessous (Horizontal - Time requis pour corriger le bogue, le type de bogue vertical - Impact sur les utilisateurs)

              | Few hours | Many hours
--------------+-----------+-------------------------
Minor problem | Might fix | Fix only if time permits
--------------+-----------+-------------------------
Major problem | Fix       | Fix

Exemple de problèmes:

              | Few hours                            | Many hours
--------------+--------------------------------------+---------------------------------
              | Window moves 1px every 10            | Windows is painted incorrectly 
Minor problem | times when you open the application. | every 100th time the app is open.
              | Fix is: handle window resize event   | Fix: Change the graphical engine.
--------------+--------------------------------------+---------------------------------
Major problem | Application crashes when opening     | Poor performance when >100 users 
              | SQL connection.                      | are connected (unusable app)
              | Fix: Fix invalid query + add Nice    | Fix: change architecture + DB
              | message                              |

La matrice peut être plus complexe avec différents niveaux de gravité, d'effort, de risques, etc.

Vous pouvez même créer un rang pour chaque bogue et les réparer en fonction du classement. Quelque chose comme:

Bug priority = Risk x Severity x Effort

* Peut-être (1-x) pour certains opérandes, en fonction de la balance que vous choisissez :)

Donc, pour répondre à votre question: dépend du type de bugs, de temps/budget disponible, etc.

8
Victor Hurdugaci

La réponse vraiment correcte serait nulle des heures sur les corrections de bugs car votre code est parfait. :-)

De manière réaliste, je ne peux pas dire que j'ai déjà entendu quelqu'un demander ou offrir ce type de ratio. Cela ne veut pas dire que certaines entreprises ne suivent pas le temps de développement et de maintenance. Mais le développement d'une application est un délai aussi court par rapport à la maintenance que la plupart des entreprises ne reviennent pas et calculent ce ratio. Ils sont probablement plus préoccupés par l'apprentissage des raisons pour lesquelles une application nécessite une maintenance et l'application de ces résultats à de nouvelles applications.

3
Walter

Il est très variaable, non seulement (bien sûr) sur l'expérience et la qualité de l'équipe, et sur la difficulté du projet (ce n'est pas la même chose qui fait une autre application Web standard qu'un nouveau noyau OS), mais également sur l'approche de gestion que vous 'll utiliser.

Par exemple, sur un modèle de cascade, vous pouvez définir précisément le premier bogue à la première phase de test, mais sur un environnement agile peut être difficile d'élever une ligne disant "d'ici, nous corrigeons des bugs", car les fonctionnalités peuvent changer ( et pour moi, ce n'est pas juste comptant un changement de fonctionnalité en tant que bogue)

De l'expérience, je dis que c'est quelque chose qui est toujours sous-estimé et peut très facilement passer la même quantité d'heures que le "projet original".

3
Khelben

Avoir trop large de critères pour ce qui est un bug peut presque doubler votre temps. Un gestionnaire trop zélé qui pense que la demande d'un client de faire un bouton plus grand (ils ont des problèmes de souris) est un excellent moyen d'augmenter le nombre de bogues que nous avons fixées. Il ne fera que quelques secondes pour résoudre ce problème car il n'est pas nécessaire de prendre en compte, de tester, de recompiler et de distribuer un patch. Oh, et il est double-compté comme une nouvelle fonctionnalité.

2
JeffO

Sur le logiciel critique, un rapport 1: 1 n'est pas inhabituel. Pour les tests d'unités seules, j'ai vu des indicateurs mentionnant 1 jour des tests d'unités pour toutes les 10 lignes de code.

1
mouviciel

Je pense que vous avez raison - vous n'allez pas obtenir de métrique significatif en raison du nombre de facteurs d'influence.

Si cela aide, je peux vous dire des projets que je travaille sur (espace d'entreprise, grands systèmes complexes, beaucoup d'intégration à d'autres systèmes) ont un rapport d'environ 3: 2. La plupart d'entre eux ne sont pas des défauts avec le code - plus généralement des défauts avec les interfaces. Par exemple, le système A et B se parler via l'interface X. Les développeurs du système A interpeller une interface X légèrement différemment des développeurs du système B. La comédie s'ensuit.

Une observation à faire est que le développement du code et du test/la fixation des bugs du code ne doit pas être deux phases distinctes. Si vous testez que vous développez, le "coût" de la fixation de bugs est inférieur.

1
darreljnz

Je pense que cela Cette question est biaisée: elle commence à partir de la présupposition que la correction de bugs est une phase similaire que le développement de nouvelles fonctionnalités. Ce n'est pas le cas.

Un bon développeur ne passera pas beaucoup de temps de débogage du code car son code sera exempt de bugs du début. Un mauvais développeur passera beaucoup de temps à déboguer son code car il ne peut pas créer d'abstractions appropriées pour résoudre des problèmes réels.

Notez que les développeurs doivent tester leur propre code eux-mêmes. C'est leur responsabilité de fournir un code sans bug. Il est donc difficile de séparer le codage du débogage.

C'est aussi une question de priorité. Lorsque vous développez, le temps nécessaire pour corriger un bogue est associé de manière exponentielle au temps passé depuis le moment où vous avez inséré le bogue dans le code. Donc, la correction des bugs devrait être plus prioritaire que de développer de nouvelles fonctionnalités.

Donc, au lieu de parler de "temps passé sur des bugs", vous devriez parler de "temps passé sur les tests" (tests d'intégration, tests d'acceptation des utilisateurs ...)

1
Jérôme Radix

Le plus gros facteur déterminant est de savoir si vous travaillez avec une nouvelle technologie ou une nouvelle technologie. Si vous travaillez avec quelque chose de nouveau et que vous développez quelque chose qui n'a pas été fait ou qui a été fait à quelques reprises dans différentes circonstances, vous allez passer beaucoup de temps sur les bugsfixes et obtenir votre projet de fonctionner comme vous le souhaitez. . Fréquemment, les bugs seront le résultat de votre travail dans un coin, et vous devrez faire des quantités importantes de travail pour restructurer ce que vous avez fait. De plus, de nombreux bugs résulteront d'une compréhension incomplète des attentes des utilisateurs et de l'absornabilité du développeur des cas de bord.

Si vous travaillez sur une technologie établie, la plupart des problèmes auront été traités par les bibliothèques ou par des pratiques dans la communauté, et vous devriez être capable de google, d'acheter ou de demander vos bugs que vous rencontrez.

1
Dan Monego

Je prends un point de vue purement pratique: qu'est-ce qui empêche l'utilité pratique du projet? Si ce sont des bugs dans les fonctionnalités existantes, vous devez corriger des bugs. S'il manque des fonctions manquantes, vous devez faire du développement original, puis revenir en arrière et corriger les bugs une fois que les fonctionnalités manquantes les plus graves sont implémentées. Cela nécessite une familiarité avec vos cas d'utilisation. Un bogue qui bloque le programme dans un boîtier d'angle étrange peut être une priorité plus faible que les améliorations mineures de la convivialité qui affectent tout le monde. Un petit bug nuisance dans la fonctionnalité la plus couramment utilisés peut être plus important qu'une caractéristique qui profite uniquement aux personnes qui poussent votre logiciel aux extrêmes.

0
dsimcha