Est-il considérablement plus coûteux de corriger un bogue à la fin du projet?
Dans n article de blog by Andrew Hay , l'axiome suivant a été posé:
Cela coûte de manière significative plus pour corriger un bogue à la fin du projet qu'il fait pour corriger le même bogue plus tôt dans le projet.
Cependant, cela ne semble pas certain, surtout après la lecture n article de blog sur moins mal et les données que j'ai vues à la sauvegarde sont extrêmement anciennes.
Est-ce que cela est toujours Axiom exacte aujourd'hui?
Les seules données difficiles que j'ai jamais vues sont Boehm et Papaccio, compréhension et contrôle des coûts de logiciel .
Cela remonte à 1988 et était une étude d'environ 80 projets logiciels. Ils ont conclu qu'une décision rendue tôt et corrigée tardive pourrait coûter 50-200 fois ce qu'elle aurait été corrigée tôt. Mais le genre de décisions très précoces dont ils parlent sont les systèmes d'exploitation à courir et à utiliser la langue et la base de données.
Ces chiffres peuvent donc être accablés par rapport au développement logiciel actuel. Cependant, nous avons maintenant beaucoup d'expérience dans le domaine et nous savons instinctivement qu'il est toujours fidèle à un point.
À l'extrême, nous savons que si une défaillance des exigences est prise juste avant que nous allions à la production, cela provoque beaucoup de retravailler et que le projet retardait ou effectivement annulé, où s'il avait été attrapé avant tout travail, nous "D ont été bien.
EDIT: Doc Brown fait un bon point dans son commentaire.
Les recherches de Boehm ont été effectuées sur des projets Cobol et Fortran à une époque où la compilation et les heures d'exécution étaient ridiculement lentes. J'ai commencé ma carrière au début des années 90 sur Cobol et le cycle de compilation et de test utilisé pour prendre si longtemps que cela valait la peine d'effort de test de sèche-tester le code avant de passer au cycle (ou au moins pendant la phase de construction, juste au cas où Vous pouvez attraper quelque chose et l'annuler tôt, vous sauver une heure environ).
À son tour, nos patrons avaient l'habitude de rire de nos plaintes car ce n'était pas si longtemps, ils devaient porter une boîte de cartes de poinçon triées à la main dans la salle serveur et laissez-la là pour une journée.
Donc, c'était définitivement plus vrai alors que c'est maintenant.
Et pourtant, très récemment, j'ai vu des blogs de réutiliser Visualisation de Steve McConnell de ce problème ( REF , daté de 1996) comme si ce graphique était en réalité basé sur des nombres difficiles. Ce n'est pas le cas. C'est une visualisation, d'expliquer son point simplement.
Je pense que le principe de Morendil, dans l'article, l'OP cité, est une bonne. La science que nous avons sur ce sujet est médiocre et obsolète et toujours traitée comme canon. Mais je pense aussi que cela attire bien et semble vrai parce que nous savons de l'expérience amère qu'il est toujours vrai, du moins à un point. Et je pense que sa phrase "discipline malade" dramatique ne lui fait aucune faveur.
Pendant que je ne suis pas au courant d'une donnée difficile ou d'autres preuves pour soutenir cette réclamation, à un minimum minimum, je pourrais comprendre son bon sens.
Pensez-y de cette façon. Si vous avez un système complexe avec des sous-systèmes inter-dépendants (comme la plupart des applications non triviales), pensez aux problèmes d'assignation pouvant résulter des modifications apportées à l'un des systèmes. Si des sous-systèmes sont prouvés comme étant corrects (par l'intermédiaire des tests unitaires et similaires) et fixé précoce, le nombre de bogues qui seront causés en raison de frapper seul sont atténués simplement en réparant tôt.
De plus, si vous réparez des bugs tôt, la mise en œuvre est toujours fraîche dans l'esprit du développeur. Selon la longueur de tout projet donné, si vous corrigez des bogues à la fin, le développeur devra passer du temps à déterminer ce qu'ils ont écrit et (peut-être) comment les sous-systèmes que leur code dépend des travaux. Temps passé à réapprendre cela = $.
Je doute que c'est du tout possible de trouver un moyen de mesurer scientifiquement rigide - il y a trop d'autres facteurs en cause et aucun projet n'est suffisamment comparable pour servir plus que des études de cas. La pensée logique devrait cependant vous donner un long chemin. Quelques arguments:
- La quantité totale de code dans un projet a tendance à se développer vers la fin. Plus vous attendez de la réparation d'un bug, plus le code de code que vous devez toucher.
- La qualité du nouveau code ajouté à un projet diminue vers la fin, au moins s'il y a une pression (qui est généralement une donnée): une date limite de métier permet aux gens de jeter les meilleures pratiques à la mer pour expédier à temps. Cela signifie que plus tard vous corrigez un bogue, plus vous devez passer du code grave.
- Même si la duplication de code est généralement fronçée, cela se produit tout le temps, et puisqu'il est facile de copier-coller, mais difficile à reprogrammer des sections de code en double, le montant d'un code collé une fois de copie augmente généralement sur la durée de vie d'un projet. Plus de code collé à copier signifie une chance plus élevée que votre bogue sera dupliqué et doit être trouvé et fixé plusieurs fois (et par conséquent, une chance plus élevée que certaines de ses occurrences soient inaperçues).
- La correction d'un bug est une modification d'une base de code; Vous espérez améliorer les choses, mais un changement porte toujours un risque. Un changement qui provoque des problèmes graves dans un projet avec des mois à parcourir devrait laisser beaucoup de poussée pour la gestion des dommages, mais deux jours avant l'expédition, vous avez des problèmes graves.
- Plus le bug lui-même existe, plus il devient probablement que d'autres parties de l'application commencent à s'appuyer sur sa mauvaise conduite. Ensuite, lorsque vous le réparez, vous déchaînez soudainement un groupe de bugs secondaires dans le code qui ne s'attend pas à ce que votre fonction fournisse réellement les résultats documentés corrects.
Ceci est des trucs de base acceptés à partir de l'ingénierie des systèmes - et s'applique à toute forme de développement technique (que ce soit des ponts de construction, des missiles, des cuirassés ou des logiciels).
Essentiellement, le coût des choses augmente environ un ordre de grandeur lorsque vous passez à travers des étapes de développement.
Quelque chose qui coûte 10 $ à réparer au point de concevoir l'idée ...
Coûtera environ 100 $ si vous avez besoin d'une mise à jour de la spécification ....
Ou coûte environ 1000 $ si quelque chose a été mis en œuvre et que vous devez apporter des modifications à ce point (et mettre à jour les spécifications, et ainsi obtenir les approbations et ainsi de suite), mais cela n'avait pas été passé par une sorte de test d'acceptation/vente officielle
Ou coûte environ 10000 $ Si quelque chose a été mis en œuvre et que vous avez accepté le client, et vous devez apporter des modifications à ce point (et mettre à jour les spécifications et obtenir les approbations, et réévaluer et réexécuter l'acceptation et la qualification du client, etc.)
Et le coût après le déploiement/déployer/mettre en service est encore plus encore.
Des exemples abondent et il est facile de les comprendre: un système bancaire avec une grave changement de portée réalisée après que vous disposiez de 25 000 employés, il coûtera un paquet de temps de ré-formation ... Avant même d'envisager la portée, le codage, le test, la régression, c etc ,c etc.
Évidemment, votre kilométrage variera: les coûts et les impacts de la modification du site Web de la chaussette électronique de la chaussette électronique de Fred Nurke sont quelque peu différents pour la modification des logiciels sur un ordinateur de contrôle de vol d'aéronefs.
Je n'ai pas accès à des données ou à des faits difficiles, je ne peux donc que vous offrir des observations anecdotiques glanées à partir de mes 20 dernières années.
Je crois qu'il existe une vaste différence entre la section de la plupart des développeurs crée un logiciel aujourd'hui par rapport à il y a 20 ans. Avec le mouvement agile ayant gagné tellement de momentum, en particulier au cours des 5 à 6 dernières années, j'ai vu un véritable changement d'attitude sur le lieu de travail. Tellement de sorte que la qualité de ce que nous faisons conscient de grandir chaque année, et avec chaque projet, car nous appliquons les leçons que nous avons apprises du projet au projet. Des processus plus maigres combinés à la mise au point sur le test - Premier développement se sont développés d'être très controversés à des places courantes. Tant de sorte que de marcher dans de nombreuses entreprises aujourd'hui, si vous n'êtes pas à l'aise avec Agile, vous aurez de la chance s'ils ne vous montrent pas la porte.
Donc, quel impact cela a-t-il eu. Tout d'abord, j'ai remarqué que les problèmes sont souvent identifiés beaucoup plus tôt. Souvent, c'est le cas que si le problème ne semble pas trop grand, il peut parfois être mis en attente indéfiniment. Dans une rare poignée de cas, j'ai vu des bugs qui étaient triviaux deviennent des problèmes graves lorsqu'ils sont abordés ultérieurement, car une question fondamentale devient apparente qui n'était pas considérée à l'époque. Parfois, cela peut conduire à un cycle de fixation dessiné et qui peut être coûteux à un degré, mais que le coût est souvent mesuré moins en termes de ressources, et plus souvent en termes d'impact sur la relation entre le client et le développeur. Les clients se développent habitués à cette façon agile de penser, qui les rend les résultats très plus rapides que cela ne le faisait dans l'ancien temps, avec des sprints de développement itératif et un retournement rapide entre les demandes et la mise en œuvre, ils s'attendent à beaucoup d'entre nous. . Et en ce qui concerne les bugs actuels, le temps nécessaire pour obtenir un bogue fixe est plus souvent considérablement réduit à la suite d'une suite solide de tests pour soutenir les modifications et la capacité de créer de nouveaux tests à partir de laquelle fournir des informations et des solutions aux problèmes rapportés.
Donc, dans l'ensemble, il semble que l'effort global de correction de bugs ait été réduit dans la plupart des cas s'il existe une série de tests solides en place et des procédures permettant de veiller à ce que les tests restent au centre de ce que le développeur fait, mais le coût réel A quelquenement décalé en partie de la part de la mise en œuvre, dans d'autres domaines de l'entreprise, car à certains égards, l'accent a également été transféré de l'approvisionnement pure et de la demande en gestion de la relation.
Une autre chose qui est devenue apparente, est que notre instinct d'ingère il y a quelques années, ce qui a suggéré d'être agile réduirait que nos cycles de maintenance ont été prouvés à la fois à la fois à droite et à la mauvaise. DROITE en ce sens que les tests solides ont permis de déboguer et de réparer notre code à une large mesure et de réduire l'ensemble le nombre de bogues libérées dans le code de production, et mal en ce sens que nous travaillons maintenant plus fort pour éviter Maintenir le code hérité, en refactorisant constamment le code et en améliorant l'architecture de sorte qu'il est de plus en plus rare que nous devons développer de nouveaux produits complètement à partir de zéro.
Donc, à la fin, qu'est-ce que cela signifie en ce qui concerne la question de l'OP? Eh bien, cela signifie que la réponse n'est vraiment pas aussi coupée et sèche que nous aurions pu le penser. Il y a 15 ans, j'aurais probablement répondu à la question d'un oui, mais maintenant je pense que c'est plus réaliste de dire qu'il est vraiment trop difficile de mesurer empiriquement, car la nature de ce que nous faisons pour développer Le logiciel a grandement changé depuis quand nous avons commencé à nous demander la question de l'opération à l'époque. D'une certaine manière, plus nous avançons nos techniques et nos compétences en tant qu'industrie, plus la question de la question se développe d'un oui définitif, à un point où je suppose que dans une courte des années, nous allons dire que peu importe que cela n'a pas d'importance Lorsque nous corrigeons des bugs, car nos tests et nos processus seront tellement plus robustes, que le moment choisi par les corrections de bugs sera moins motivé par les efforts visant à sauver nos budgets, et plus de priorités pour satisfaire les besoins de nos clients et que le coût relatif sera devenir pratiquement sans signification de manière contextuelle.
Mais comme je le disais, ce n'est pas des preuves soutenues par des données difficiles, juste mes observations des dernières années et mon intestin me disent qu'il y aura plus de sagesse tremblante au sol à venir qui améliorera la façon dont nous faisons les choses.
Une fois, j'ai lu un article qui avait deux points intéressants (malheureusement, les références que j'avais eues depuis longtemps, je devrai simplement postuler ici). Le premier point qu'ils ont fait était que, environ 50% de toutes les erreurs étant introduites dans les spécifications des exigences et qu'environ 90% de toutes les erreurs trouvées lors des tests UAT ou SYSTEM.
Le deuxième point qu'ils avaient était que pour chaque phase du modèle V, le coût a été augmenté à 10 fois. Si le facteur est correct ou non, je trouve un type de pertinence, mais les erreurs les plus coûteuses sont lorsque votre conception est basée sur une hypothèse incorrecte. Cela conduit à une quantité massive de rédaction. Tout le code qui fonctionne en raison de cette hypothèse mais échoue lorsque la bonne hypothèse est appliquée devra être réécrite.
J'ai vécu l'intégralité du modèle de domaine devant être réécrit en raison d'une hypothèse incorrecte dans les spécifications des exigences. Si un tel bogue est pris tôt, c'est-à-dire lors de la révision des spécifications des exigences. Le coût est très faible. Dans ce cas particulier, il aurait pris dix lignes de texte. Dans le cas où il se trouve lors de l'UAT (comme c'était), le coût est résancial (dans l'exemple donné, le coût du projet a été augmenté de 50%)
Aucune donnée statistique, mais expérience personnelle:
Le code de contrôle du moteur de la fusée que je travaillais a eu une ligne comme powerCutoff = someCondition && debugOptions.cutoffIsAllowed;. L'option par défaut n'était pas autorisée. La construction "finale" était censée supprimer toutes les options de débogage. La ligne a donc été modifiée à powerCutoff = someCondition;.
Avez-vous attrapé le bogue pendant la revue de code? Nous n'avons pas fait. La première fois que la condition de déclenchement s'est produite lors du test provoquant une coupure inattendue n'était que quelques mois avant le premier vol.
Ce bug aurait coûté moins d'une heure aurait été pris au cours de l'examen. Cela aurait peut-être coûté une journée ou deux si elle a été prise pendant l'intégration, ce qui entraîne une répétition d'un test unique. Si elle a été prise pendant la qualification formelle, cela aurait pu coûter une semaine ou deux en faisant une série de séries de test complet avec une nouvelle construction.
Comme c'était, le coût a-t-il balnéaire. Premièrement, nous avons conçu et avons couru des tests pour déterminer si l'unité de vol pourrait même déclencher la condition. Après avoir été déterminée comme étant une possibilité réelle, il y avait des coûts pour l'ingénierie, la gestion et l'analyse de la clientèle de la meilleure solution, libérant ainsi la nouvelle construction, créant et exécutant un nouveau plan de test de régression, des tests de système dans plusieurs unités et simulateurs. Dans l'ensemble, cela coûte des milliers de personnes sinon des dizaines de milliers d'heures d'homme. Plus l'original 15 minutes pour faire le bon changement de code.
Les premiers bugs se propageront à d'autres parties du système afin que vous fixez le bogue que vous pouvez être obligé de réécrire certaines parties du système reposant sur le bogue lui-même.
À côté du temps, vous ferez la construction de certaines parties du programme et vous devez vous rappeler. C'est une forme de dette technique (si vous précipitez le projet au stade précoce, vous aurez des problèmes de la finition en raison de raccourcis que vous avez pris).
C'est aussi simple que cela et il n'y a rien à preuve.
Je pense que vous essayez de précipiter le projet aussi vite que possible pour présenter une solution de travail à votre employé. Une bonne nouvelle est que vous l'aurez très vite, de mauvaises nouvelles est que vous ne le terminerez probablement jamais sans réécriture complète si vous continuez à écrire de la merde aussi vite que possible et à planifier tout régler dans quelques mois. Vous ne pourrez probablement même pas refroidir cela.
Eh bien, je ne peux probablement pas vous donner la preuve définitive que vous demandez, mais je peux raconter un incident assez récent de mon travail.
Nous avons ajouté une fonctionnalité qui fournissait des capacités de gestion de Workflow à notre produit. Typique BDUF Stuff, spécifications signées et approuvées par le client. Mis en œuvre sur les spécifications. Plaintes du jour 1 sur le déploiement.
Nous n'avions pas fait une réelle promotion de la convivialité avec le client, il suffit de prendre leur parole pour ce qu'ils voulaient. Résultat: des centaines d'heures de retravaque - analyse, conception, mise en œuvre et qa ont dû être refaites. Tous parce que la spécification a raté les cas d'utilisation particulière. Un bogue dans la spécification, si vous voulez.
J'ai vu des choses similaires dans des tâches antérieures lorsque quelqu'un de la chaîne fait des hypothèses différentes des hypothèses de l'utilisateur final. Les bogues de codage tout droit sont relativement faciles à gérer si elles sont prises près de quand elles se produisent, mais les bugs design peuvent tuer des systèmes entiers.
Malheureusement, comme beaucoup de choses, cela dépend.
Si un message de dialogue est mal orthographié, il peut être "trivial" à corriger (mettre à jour la chaîne, reconstruction/package, redéployer). Ou si une mise à jour a besoin d'une mise à jour, une modification d'un fichier .CSS peut suffire.
Si le bogue est que la sortie d'une méthode critique qui possède une spécification et une preuve de plus de 100 pages est fausse, l'enquête elle-même peut prendre des heures ou des jours. C'est ce que l'ancien "axiome" fait référence à et quoi, entre autres choses, TDD et Agile essaient d'éviter (échouer tôt et clairement, faire des progrès incrémentiels sûrs, Yada).
Depuis mon expérience récente avec des équipes multi-Scrum sur un seul projet, les "bugs" sont généralement des problèmes de fusion/d'intégration qui n'apparaissent que à la fin d'une libération en tant que branches de fonctionnalités sont promues stables. Ce sont les pires, car les conflits nécessitent souvent un soutien d'équipe transversale tandis que les équipes sont en rafale pour terminer leurs propres objectifs, mais je ne sais pas qu'ils sont plus chers que d'autres bugs, comme ils se produisent quand ils se produisent quand ils se produisent: la libération, mais le plus tôt possible. C'est ce qui en fait le pire.