Wie Viel Zeit Sollte Zugeteilt werden, für die Prüfung & Bug-Fixing
Jedes mal, wenn ich schätzen die Zeit, die für ein Projekt (oder jemand anderes abgeben Schätzung), Zeit wird zugeteilt, für die Prüfung/Behebung wird zwischen alpha-und Produktions-releases. Ich weiß sehr wohl, dass die Schätzung so weit in der Zukunft zu einem problem-die unbekannte Größe ist nicht ein gutes Rezept für eine erfolgreiche Schätzung. Jedoch für eine Vielzahl von Gründen, die eine definierte Anzahl von Stunden immer zugewiesen bekommt, von Anfang an auf dieses segment der Arbeit. Und je weiter Weg von diesem ersten Schätzung ist von den wirklichen, endgültigen Wert, der mehr Kummer derjenigen, die sich mit dem debugging werde später, wenn Sie gehen "über" Schätzung.
Also meine Frage ist: was ist die beste Strategie, die Sie gesehen haben, mit Bezug auf die Schätzungen wie diese? Einen Prozentsatz des Gesamt-dev Schätzung? Legen Sie die Anzahl der Stunden (mit der Erwartung, dass es nach oben gehen)? Etwas anderes?
Etwas anderes zu betrachten: wie würden Sie diese Antwort anders, wenn der AUFTRAGGEBER ist verantwortlich für die Prüfung (im Gegensatz zu internen QA) und ordnen Sie eine Menge Zeit für die Reaktion auf die Fehler, die Sie möglicherweise oder möglicherweise nicht finden (so Sie brauchen, um herauszufinden, die Zeit-Schätzungen für bug-fixing, aber nicht für die Prüfung)
Du musst angemeldet sein, um einen Kommentar abzugeben.
Es hängt wirklich von vielen Faktoren ab. Nur einige zu nennen: die Entwicklung der Methodik, die Sie verwenden, die Anzahl der Tests Ressource, die Sie haben, die Anzahl von Entwicklern, die zu diesem Zeitpunkt im Projekt (viele Projektmanager die Menschen bewegen sich auf etwas neues am Ende).
Als Rob Rolnick sagt 1:1 ist eine gute Faustregel - allerdings in Fällen, in denen eine Spezifikation ist schlecht, kann die client-push für "bugs", die sind tatsächlich schlecht angegeben Funktionen. Ich war kürzlich an einem Projekt beteiligt, die viele Versionen, aber mehr verbrachte Zeit auf bug-fixing als die tatsächliche Entwicklung aufgrund der schrecklichen Spezifikation.
Sorgen für eine gute Spezifikation/design und Ihre testing/Bugfixing-Zeit reduziert wird, weil es leichter sein wird für den Tester, um zu sehen, was und wie zu testen und alle clients haben weniger lee-Weg zu schieben für zusätzliche Funktionen.
Vielleicht schreib ich einfach buggy code, aber ich mag mit einem 1:1-Verhältnis zwischen devs und tests. Ich nicht warten, bis die alpha zu testen, sondern machen es durch das gesamte Projekt. Die Logik? Je nach release-Zeitplan, es könnte ein gutes Geschäft in der Zeit zwischen, wenn die Entwicklung beginnt, und wenn Sie Ihre alpha -, beta -, und Lieferdaten werden. Außerdem, je früher Sie fangen bugs, die einfacher (und billiger) sind Sie zu beheben.
Einen guten tester, die bugs bald nach jedem check-in ist von unschätzbarem Wert. (Oder, besser noch, bevor ein check-in von einer PR-oder DPK) Einfach gesagt, ich bin immer noch sehr vertraut mit meinem code, so dass die meisten bug-fixes werden super einfach. Mit diesem Ansatz, Neige ich dazu, Sie zu verlassen, rund 15% von meinem dev Zeit für bug-fixing. Zumindest wenn ich Schätzungen. Also in der 16 Woche laufen würd ich lassen Sie etwa 2-3 Wochen.
Sich aus der Prüfung Bibel:
Testen Von Computer-Software
p. 31: "die Prüfung [...] Konten für 45% der anfänglichen Entwicklung eines Produkts." Eine gute Faustregel ist daher, zu reservieren über die Hälfte Ihrer gesamten Aufwand für Tests während der Anfangsphase der Entwicklung.
Nur eine gute Menge an gesammelten Statistiken aus vorangegangenen Projekten kann Ihnen helfen, genaue Schätzungen. Wenn Sie eine gut definierte Reihe von Anforderungen erfüllen, können Sie eine grobe Berechnung, wie viele Fälle Sie haben. Wie ich sagte, müssen Sie einige Statistiken für Ihr team. Sie müssen wissen, der Durchschnittliche Fehler pro loc Anzahl zu schätzen bugs insgesamt zählen. Wenn Sie nicht über solche zahlen für Ihre Teams, die Sie verwenden können,Industrie Durchschnitt zahlen. Nachdem man geschätzte LOC (Anzahl der Anwendungsfälle * NLOC) und der Durchschnittliche Fehler-pro-Zeilen, können Sie mehr oder weniger genaue Schätzung der Zeit benötigt, um release-Projekt.
Aus meiner praktischen Erfahrung, verbrachte Zeit auf bug-fixing ist gleich oder mehr (in 99% der Fälle 🙂 ) als die Zeit, die verbracht wird auf dem original-Umsetzung.
Verwenden Sie eine Sprache, die mit Design-by-Contract oder "Code-Verträge" (Voraussetzungen, überprüfen Sie die Behauptungen, post-Bedingungen, Klassen-Invarianten, etc), um zu "testen" und so nah an Ihre Klassen und Klassen Funktionen (Methoden und Eigenschaften) wie möglich. Dann verwenden TDD testen Sie Ihren code mit den Verträgen.
Verwenden Sie so viel selbst gebaut, code-Generierung, wie Sie möglicherweise können. Generierte code ist nachweislich vorhersagbare, leichter zu Debuggen und einfacher/schneller zu beheben, als alles von hand coded code. Warum schreiben Sie das, was Sie generieren können? Verwenden Sie jedoch nicht die OPG (andere-Völker-Generatoren)! Code, den SIE erzeugen, ist der code, den Sie kontrollieren und wissen.
Können Sie erwarten, zu verbringen einen invertierenden Verhältnis über den Verlauf Ihres Projekts--das ist--Sie schreiben, viele hand-code und Verträge in der start (1:1) von Ihrem Projekt. Wie Sie sehen Muster, lehren, einen code-generator, den SIE SCHREIBEN, um den code für Sie generieren und wiederverwenden. Je mehr Sie erzeugen können, die weniger, die Sie entwerfen, schreiben, Debuggen und testen. Am Ende des Projekts, finden Sie, dass Ihre Gleichung invertiert: schreiben Sie weniger von Ihrer Kern-code, und Ihren Fokus auf Ihre "leaf-code" (last-mile) oder spezialisierte (vs generalisierte und generierten) code.
Schließlich--bekommen Sie einen code-analyzer. Eine gute, automatisierte code-Analyse, Regel-system und-Motor, sparen Sie Unmengen an Zeit bei der Suche "dumm-Fehler", denn es gibt bekannte Probleme, wie die Leute schreiben von code in bestimmten Sprachen. In Eiffel, haben wir nun Eiffel-Inspektor, wo wir nicht nur die 90+ Regeln kommen, aber lernen zu schreiben unsere eigenen Regeln für unseren eigenen entdeckt "Fallstricke". Solche Analysatoren sparen Sie also nicht nur in Bezug auf bugs, aber verbessern Sie Ihre design-auch GRÜN-Programmierer "get it" eher schnell und stoppen Sie die Anfängerfehler früher und schneller lernen!
Die Faustregel für das umschreiben von bestehenden Systemen ist diese: "Wenn es dauerte 10 Jahre, um zu schreiben, es wird 10 Jahre dauern, um wieder schreiben." In unserem Fall, mit Eiffel, Design-by-Contract, Code-Analyse und Code-Generierung, die wir neu geschrieben haben, ein 14-Jahr-system in 4 Jahren und wird voll liefern in 4 1/2. Das neue system ist etwa 4x bis 5x komplexer als das alte system, also das sagt eine Menge!