Combien de Temps Devrait être Alloué pour les Tests & correction d'un Bug

Chaque fois que je dois estimer le temps pour un projet (ou d'un examen de quelqu'un d'autre estimation), le temps est alloué pour les tests et correction d'un bug qui va être fait entre l'alpha et la production de rejets. Je sais très bien que l'estimation de si loin dans le futur à l'égard d'un problème-ensemble de taille inconnue n'est pas une bonne recette pour le succès d'une estimation. Cependant, pour une variété de raisons, un nombre défini d'heures invariablement est affectée au début de ce segment de travail. Et le plus loin cette première estimation est de la vraie, la valeur finale, plus de chagrin à ceux qui sont impliqués avec le débogage aurez à prendre, plus tard, lorsqu'ils aller "au-dessus" de l'estimation.

Donc ma question est: quelle est la meilleure stratégie que vous avez vu en ce qui concerne ce qui rend les estimations de ce genre? Un plat pourcentage de l'ensemble de dev estimation? Nombre d'heures de travail (avec l'espoir qu'il va aller jusqu')? Quelque chose d'autre?

Autre chose à considérer: comment voulez-vous répondre de façon différente si le client est responsable de l'essai (par opposition à contrôle qualité interne) et vous devez attribuer une quantité de temps pour répondre aux bugs qu'ils peuvent ou ne peuvent pas trouver (si vous avez besoin de trouver des estimations de temps pour la correction de bug, mais pas pour les tests)

OriginalL'auteur Yaakov Ellis | 2008-09-07

  1. 9

    Cela dépend vraiment de beaucoup de facteurs. Pour n'en citer que quelques-uns: la méthode de développement que vous utilisez, le nombre de contrôles de ressources que vous avez, le nombre de développeurs disponibles à ce stade du projet, (beaucoup de gestionnaires de projets à faire bouger les gens sur quelque chose de nouveau à la fin).

    De Rob Rolnick, dit 1:1 est une bonne règle de base - toutefois, dans les cas où un cahier des charges est mauvais, le client peut pousser pour les "bugs" qui sont en fait mal fonctionnalités spécifiques. J'ai été récemment impliqué dans un projet qui a utilisé de nombreux communiqués, mais plus de temps a été passé sur la correction de bug que le réel développement en raison de la terrible spécification.

    Assurer une bonne spécification et de conception et de test/correction d'un bug de temps sera réduit car il sera plus facile pour les testeurs de voir en quoi et comment le test et les clients auront moins de lee-chemin pousser pour des fonctionnalités supplémentaires.

    OriginalL'auteur Rob Stevenson-Leggett

  2. 6

    Peut-être que je viens d'écrire du code bogué, mais j'aime avoir un ratio de 1:1 entre les devs et les tests. Je ne pas attendre jusqu'à ce que l'alpha test, mais plutôt de le faire tout au long de l'ensemble du projet. La logique? En fonction de votre calendrier de libération, il pourrait être une bonne affaire de temps entre le moment où le développement commence et quand votre alpha, bêta, et des dates de livraison sont. En outre, plus tôt bugs, le plus facile (et moins cher) qu'ils sont à corriger.

    Un bon testeur, qui à trouver des bogues, peu de temps après chaque check-in, est inestimable. (Ou, mieux encore, avant de faire un check-in à partir de RP ou DPK) bref, je suis encore très familier avec mon code, donc la plupart des corrections de bugs de devenir super simple. Avec cette approche, j'ai tendance à laisser environ 15% de mon dev de temps pour la correction de bug. Au moins, quand je ne les estimations. Donc, au cours de 16 semaines je partirais d'environ 2-3 semaines.

    OriginalL'auteur Rob Rolnick

  3. 5

    De l'essai de la Bible:

    Ordinateur De Test Logiciel
    Combien de Temps Devrait être Alloué pour les Tests & correction d'un Bug

    p. 31: "Tests [...] représente 45% de la création initiale d'un produit." Une bonne règle de base est donc d'allouer environ la moitié de votre total de l'effort de test au cours du développement initial.

    OriginalL'auteur lindelof

  4. 4

    Seulement une bonne quantité de statistiques accumulées à partir de précédents projets, peut vous aider à donner des estimations précises. Si vous avez un bien défini d'exigences, vous pouvez faire un calcul approximatif du nombre de cas d'utilisation que vous avez. Comme je l'ai dit, vous devez avoir quelques statistiques pour votre équipe. Vous avez besoin de connaître la moyenne des bugs par-loc nombre d'estimer le total des bugs comte. Si vous ne disposez pas de ces numéros pour votre équipe, vous pouvez utiliser la moyenne de l'industrie numéros. Après avoir estimé LOC (nombre de cas d'utilisation * NLOC) et la moyenne des bugs par lignes, vous pouvez donner plus ou moins précise d'estimation sur le temps nécessaire à la communication du projet.

    À partir de mon expérience pratique, le temps passé sur le bug de fixation est égale à ou plus (dans 99% des cas 🙂 ) que le temps passé sur la mise en œuvre d'origine.

    OriginalL'auteur aku

  5. 2

    Usage de la langue avec la Conception par Contrat ou "Code-contrats" (conditions, vérifier les assertions, les post-conditions, la classe d'invariants, etc) pour obtenir des "tests" en tant que proche de vos classes et de fonctions de classe (méthodes et propriétés) que possible. Ensuite, utilisez TDD pour tester votre code avec ses contrats.

    Utilisation comme beaucoup d'auto-construit de génération de code que vous pouvez éventuellement. Le code généré est prouvé, prévisible, plus facile à déboguer, et plus facile/rapide à corriger que tous codés à la main code. Pourquoi écrire ce que vous pouvez générer? Cependant, ne pas utiliser de l'OPG (autres peuples--générateurs)! Code VOUS générez est le code de votre contrôle et vous le savez.

    Vous pouvez vous attendre à passer une inversion par rapport au cours de votre projet, c'est--vous d'écrire beaucoup de main-code et de contrats au début (1:1) de votre projet. Comme vous le voyez habitudes, apprendre à un générateur de code que VOUS ÉCRIVEZ pour générer le code pour vous et de le réutiliser. Le plus vous produisez, moins de concevoir, d'écrire, de débogage et de test. D'ici la fin du projet, vous trouverez que votre équation a inversé: Vous êtes à la rédaction de votre base de code, et votre attention se déplace à votre "feuille de code" (dernier kilomètre) ou spécialisés (vs généralisée et de la génération de code.

    Enfin, un analyseur de code. Une bonne, de code automatisé de règles d'analyse du système et le moteur vous fera économiser des tonnes de temps à la recherche de "stupide-bugs" parce qu'il y a bien connu des problèmes dans la façon d'écrire du code dans des langues particulières. En Eiffel, nous avons maintenant Eiffel Inspecteur, où l'on peut non seulement utiliser la 90+ règles à venir avec elle, mais apprennent à écrire nos propres règles pour nos propres découvertes "pièges". Ces analyseurs non seulement vous sauver en termes de bugs, mais d'améliorer votre conception--même VERT programmeurs "get it" assez rapidement et arrêter de faire des erreurs de débutant plus tôt et à apprendre plus vite!

    La règle de base pour la réécriture des systèmes existants est ceci: "Si il a fallu 10 ans pour l'écrire, il faudra 10 ans pour ré-écrire." Dans notre cas, en utilisant Eiffel, la Conception par Contrat, le Code d'Analyse et de Génération de Code, nous avons ré-écrit, de 14 ans à 4 ans et se livrer entièrement à 4 1/2. Le nouveau système est d'environ 4x 5x plus complexe que l'ancien système, c'est beaucoup dire!

    OriginalL'auteur Larry