La rentabilité relative du développement piloté par les tests (d'acceptation)


15

Je voudrais savoir quel est l'impact global de la planification des ressources sur un projet logiciel, où les exigences et la conception du projet sont déterminées par des tests d'acceptation automatisés et des tests unitaires, contrairement à une approche plus "traditionnelle" du développement logiciel.

entrez la description de l'image ici

D'après votre expérience, quel est l'effet global sur les besoins en ressources pour la réalisation d'un projet logiciel sous TDD, par opposition aux méthodologies de développement plus "traditionnelles"? Il me semble évident que la qualité augmenterait et que le degré d'incertitude diminuerait parce que les tests sont effectués plus tôt, mais exiger des tests à l'avance semble nécessiter plus d'heures de développement. Dans quelle mesure l'effort de développement augmente-t-il ou diminue-t-il réellement en raison de l'élimination immédiate des bogues?

Combien d'efforts supplémentaires de la part du client? Doivent-ils changer la façon dont ils se rapportent au projet, surtout s'ils sont habitués au gros design dès le départ? Le nombre d'heures requis du client augmente-t-il globalement ou diminue-t-il réellement?

J'imagine que les estimations de temps seraient très vagues dans un processus TDD itératif au début d'un projet TDD (car il n'y a pas de plan de développement logiciel). Y a-t-il un point, disons, 20% dans un projet, où la confiance augmente suffisamment pour qu'une estimation de temps et d'argent plus ou moins stable puisse éventuellement être fournie au client?

Remarque: Je ne recherche pas d'opinions ou de théories subjectives ici, alors ne spéculez pas. Je recherche plus d'expérience dans le monde réel en TDD.


Je suis sûr qu'il n'y a pas de données réelles. Vous obtenez uniquement des opinions et des théories subjectives basées sur l'expérience du monde réel de Peoeple.
Euphoric

1
@Euphoric: Je recherche des observations et des réalités objectives basées sur l'expérience du monde réel. Désolé, je n'ai pas précisé cela. Cependant, je n'ai pas besoin de chiffres précis; J'accepterai des impressions générales telles que: "alors que notre temps de développement a augmenté considérablement, nos coûts de maintenance ont diminué parce que le logiciel était plus fiable et le client comprenait mieux le logiciel parce qu'il a participé à la conception tout au long de l'effort de développement."
Robert Harvey

2
Alors, est-ce une question d'opinion? Cela ressemble certainement à un
BЈовић


@ BЈовић: Voir le dernier paragraphe dans mon corps de question.
Robert Harvey

Réponses:


11

La première chose à préciser est que TDD n'augmente pas nécessairement la qualité du logiciel (du point de vue de l'utilisateur). Ce n'est pas une solution miracle. Ce n'est pas une panacée. Diminuer le nombre de bugs n'est pas la raison pour laquelle nous faisons TDD.

TDD se fait principalement parce qu'il se traduit par un meilleur code. Plus précisément, TDD génère un code plus facile à modifier .

Que vous souhaitiez ou non utiliser TDD dépend plus de vos objectifs pour le projet. Est-ce que ce sera un projet de conseil à court terme? Devez-vous soutenir le projet après sa mise en service? Est-ce un projet banal? Les frais généraux ajoutés peuvent ne pas en valoir la peine dans ces cas.

Cependant, d'après mon expérience, la proposition de valeur pour TDD croît de façon exponentielle à mesure que le temps et les ressources impliqués dans un projet croissent de façon linéaire.

De bons tests unitaires offrent les avantages suivants:

  1. Les tests unitaires avertissent les développeurs des effets secondaires involontaires.
  2. Les tests unitaires permettent le développement rapide de nouvelles fonctionnalités sur des systèmes anciens et matures.
  3. Les tests unitaires donnent aux nouveaux développeurs une compréhension plus rapide et plus précise du code.

Un effet secondaire du TDD pourrait être moins de bogues, mais malheureusement, d'après mon expérience, la plupart des bogues (en particulier les plus méchants) sont généralement causés par des exigences peu claires ou médiocres ou ne seraient pas nécessairement couverts par le premier cycle de tests unitaires.

Pour résumer:

Le développement sur la version 1 pourrait être plus lent. Le développement sur la version 2-10 sera plus rapide.


1
J'aime que la juxtaposition explicite d'un «meilleur code» soit différente de l'augmentation de «la qualité du logiciel», c'est-à-dire que les choses que les programmeurs apprécient dans le code ne sont pas nécessairement qu'il fait ce que le client veut.

1
Les tests d'acceptation et les tests unitaires initiaux ne sont-ils pas censés clarifier les exigences?
Robert Harvey

@RobertHarvey Ils devraient l' être mais ne le sont pas nécessairement . Les tests unitaires et les tests d'acceptation refléteront la compréhension par le développeur des exigences lors de leur rédaction. Les développeurs peuvent avoir tout, d'une compréhension complète à aucune compréhension des exigences lorsqu'ils commencent à écrire le logiciel. Cette partie de l'équation dépend beaucoup plus du client et du chef de produit qu'autre chose. Théoriquement, les tests devraient beaucoup aider. En pratique, eh bien, "cela dépend".
Stephen

1
Je dois préciser que nous parlons ici de TDD isolément, et non d'une implémentation SCRUM qui intègre TDD. Isolément, TDD consiste à écrire des tests afin que vous écriviez un meilleur code et que vous puissiez refactoriser plus rapidement et en toute sécurité plus tard.
Stephen

1
@Stephen: J'aurais peut-être dû préciser que je parle de la saveur du TDD qui intègre des tests d'acceptation dans le cadre du processus de collecte des exigences. J'ai ajouté un graphique à la question pour le clarifier.
Robert Harvey

6

Il y a un chapitre dans Making Software about Test-Driven Development, qui cite le papier discuté ici .

Des études de cas ont été menées avec trois équipes de développement chez Microsoft et une chez IBM qui ont adopté TDD. Les résultats des études de cas indiquent que la densité des défauts avant la libération des quatre produits a diminué entre 40% et 90% par rapport à des projets similaires qui n’utilisaient pas la pratique TDD. Subjectivement, les équipes ont connu une augmentation de 15 à 35% du temps de développement initial après l'adoption de TDD.

La question de savoir si ces résultats peuvent être généralisés à votre cas est, bien sûr, quelque chose que les partisans du TDD diront est évident et les détracteurs du TDD diront qu'il est faux.


4
Le problème avec cette étude est qu'ils n'ont pas testé le code à l'unité avant d'adapter TDD. TDD n'est pas un outil magique qui réduit le nombre de défauts de 40 à 90% en l'adoptant simplement
BЈовић

1
@ BЈовић Je ne pense pas qu'ils prétendent "magie" nulle part dans ce journal. Ils affirment que certaines équipes ont adopté TDD, d'autres non, on leur a confié un travail "similaire" et des densités de défauts et des temps de développement ont été enregistrés. S'ils avaient forcé les équipes non-TDD à écrire des tests unitaires de toute façon juste pour que tout le monde ait des tests unitaires, ce ne serait pas une étude écologiquement valable.

Une étude écologiquement valable? Sorta dépend de ce que vous mesurez. Si vous voulez savoir si écrire vos tests à l'avance est important, alors tout le monde doit écrire des tests unitaires, pas seulement le groupe TDD.
Robert Harvey

1
@robert Harvey, c'est une question de confusion des variables, pas de validité écologique. La conception d'une bonne expérience implique un dégradé de ceux-ci. Par exemple, si le groupe de contrôle écrivait des tests unitaires post hoc, les gens diraient que l'expérience n'était pas saine parce que le groupe de contrôle fonctionnait d'une manière inhabituelle trouvée dans la nature.

2
Heureusement, je n'ai pas dit qu'ils l'étaient.

5

Je n'ai pas de documents de recherche ou de statistiques à vous fournir, mais je vais vous raconter mon expérience de travail dans une équipe / organisation qui, historiquement, avait une couverture de tests unitaires faible à moyenne et aucun test de bout en bout, et progressivement déplacer la barre là où nous en sommes maintenant, avec plus d'une approche ATDD (mais, ironiquement, pas traditionnelle TDD).

Plus précisément, c'est ainsi que les échéanciers du projet se déroulaient (et se déroulent toujours sur d'autres équipes / produits de la même organisation):

  • Jusqu'à 4 semaines d'analyse et de mise en œuvre
  • 2 semaines de tests de régression, correction de bogues, stabilisation et préparation de versions
  • 1-2 semaines de réparation des défauts connus
  • 2-3 semaines de nettoyage de code et problèmes / support de post-production (défauts inconnus / pannes imprévues)

Cela semble ridicule, mais c'est en fait très courant, il est souvent masqué dans de nombreuses organisations par une assurance qualité manquante ou inefficace. Nous avons de bons testeurs et une culture de tests intensifs, donc ces problèmes sont détectés tôt et résolus à l'avance (la plupart du temps), plutôt que d'être autorisés à jouer lentement au cours de plusieurs mois / années. Les coûts de maintenance de 55 à 65% sont inférieurs à la norme communément acceptée de 80% du temps consacré au débogage - ce qui semble raisonnable, car nous avons eu quelques tests unitaires et des équipes interfonctionnelles (y compris l'AQ).

Lors de la première version de notre dernier produit par notre équipe, nous avions commencé à moderniser les tests d'acceptation, mais ils n'étaient pas tout à fait à la hauteur et nous devions encore compter sur de nombreux tests manuels. La publication a été un peu moins douloureuse que d'autres, l'OMI en partie à cause de nos tests d'acceptation au hasard et aussi en partie à cause de notre couverture de tests unitaires très élevée par rapport à d'autres projets. Pourtant, nous avons passé près de 2 semaines sur la régression / stabilisation et 2 semaines sur les problèmes de post-production.

En revanche, chaque version depuis cette version initiale a eu des critères d'acceptation et des tests d'acceptation anticipés, et nos itérations actuelles ressemblent à ceci:

  • 8 jours d'analyse et de mise en œuvre
  • 2 jours de stabilisation
  • 0-2 jours combinés de support et de nettoyage post-production

En d'autres termes, nous sommes passés de 55 à 65% de frais de maintenance à 20 à 30% de frais de maintenance. Même équipe, même produit, la principale différence étant l'amélioration progressive et la rationalisation de nos tests d'acceptation.

Le coût de leur maintenance est, par sprint, de 3 à 5 jours pour un analyste QA et de 1 à 2 jours pour un développeur. Notre équipe compte 4 développeurs et 2 analystes QA, donc (sans compter l'UX, la gestion de projet, etc.), c'est un maximum de 7 jours-homme sur 60, que j'arrondirai à une surcharge de mise en œuvre de 15% juste pour être sur le côté sûr.

Nous passons 15% de chaque période de mise au point à développer des tests d'acceptation automatisés, et dans le processus, nous sommes en mesure de réduire 70% de chaque version en effectuant des tests de régression et en corrigeant les bogues de pré-production et de post-production.

Vous avez peut-être remarqué que la deuxième chronologie est beaucoup plus précise et aussi beaucoup plus courte que la première. C'est quelque chose qui a été rendu possible par les critères d'acceptation et les tests d'acceptation initiaux, car cela simplifie considérablement la "définition du fait" et nous permet d'être beaucoup plus confiants dans la stabilité d'une version. Aucune autre équipe n'a (jusqu'à présent) réussi avec un calendrier de publication bihebdomadaire, sauf peut-être lors de versions de maintenance assez triviales (correction de bugs uniquement, etc.).

Un autre effet secondaire intéressant est que nous avons pu adapter notre calendrier de sortie aux besoins de l'entreprise. Une fois, nous avons dû l'allonger à environ 3 semaines pour coïncider avec une autre version, et nous avons pu le faire tout en offrant plus de fonctionnalités, sans passer de temps supplémentaire à tester ou à stabiliser. Une autre fois, nous avons dû la raccourcir à environ 1½ semaine, en raison de vacances et de conflits de ressources; nous avons dû prendre moins de travail de développement, mais, comme prévu, nous avons pu consacrer en conséquence moins de temps aux tests et à la stabilisation sans introduire de nouveaux défauts.

Ainsi, d'après mon expérience, les tests d'acceptation, en particulier lorsqu'ils sont effectués très tôt dans un projet ou un sprint, et lorsqu'ils sont bien entretenus avec des critères d'acceptation écrits par le propriétaire du produit, sont l'un des meilleurs investissements que vous puissiez faire. Contrairement au TDD traditionnel, qui, à juste titre, est souligné par d'autres, se concentre davantage sur la création de code testable que sur un code sans défaut - ATDD aide vraiment à détecter les défauts beaucoup plus rapidement; c'est l'équivalent organisationnel d'avoir une armée de testeurs faisant un test de régression complet tous les jours, mais beaucoup moins cher.

ATDD vous aidera-t-il dans des projets à plus long terme réalisés en style RUP ou (ugh) Waterfall, des projets d'une durée de 3 mois ou plus? Je pense que le jury est toujours sur celui-là. D'après mon expérience, les risques les plus importants et les plus laids dans les projets de longue durée sont des délais irréalistes et des exigences changeantes. Des délais irréalistes obligeront les utilisateurs à prendre des raccourcis, y compris des tests de raccourcis, et des modifications importantes des exigences invalideront probablement un grand nombre de tests, les obligeant à être réécrits et à gonfler potentiellement les frais généraux d'implémentation.

Je suis à peu près sûr qu'ATDD a un gain fantastique pour les modèles Agile ou pour les équipes qui ne sont pas officiellement Agiles mais ont des calendriers de sortie très fréquents. Je ne l'ai jamais essayé sur un projet à long terme, principalement parce que je n'ai jamais été dans ou même entendu parler d'une organisation disposée à l'essayer sur ce type de projet, alors insérez l'avertissement standard ici. YMMV et tout ça.

PS Dans notre cas, aucun effort supplémentaire n'est requis de la part du "client", mais nous avons un Product Owner dédié à temps plein qui rédige en fait les critères d'acceptation. Si vous êtes dans le domaine du "consultingware", je pense qu'il pourrait être beaucoup plus difficile d'amener les utilisateurs finaux à écrire des critères d'acceptation utiles. Un Product Owner / Product Manager semble être un élément assez essentiel pour faire de l'ATDD et bien que je ne puisse à nouveau parler que de ma propre expérience, je n'ai jamais entendu parler d'ATDD pratiqué avec succès sans quelqu'un pour remplir ce rôle.


C'est très utile, merci. Il ne m'est pas venu à l'esprit que ATTD pourrait changer le caractère de l'effort TDD, mais cela a du sens, surtout quand vous entendez parler de gens qui sont capables de produire des logiciels bien écrits et relativement sans bogue à temps et selon le budget sans utilisant nécessairement des tests unitaires intensivement.
Robert Harvey

@RobertHarvey: Je dois préciser - nous créons toujours des tests unitaires, mais pas dans le cadre d'un processus TDD. Généralement, les tests d'acceptation viennent en premier ou en parallèle avec le développement initial, puis le code est terminé, puis les tests unitaires et le refactoring. J'ai parfois pensé que TDD aiderait certains développeurs à écrire un meilleur code, mais je ne peux pas (encore) le sauvegarder. Bien que je puisse parler pour moi-même, j'attrape souvent beaucoup de bogues et de défauts de conception dans mon propre code simplement pendant le processus d'écriture des tests unitaires.
Aaronaught

1

Besoins en ressources

D'après votre expérience, quel est l'effet global sur les besoins en ressources pour la réalisation d'un projet logiciel sous TDD, par opposition aux méthodologies de développement plus "traditionnelles"?

D'après mon expérience, le coût d'exiger des tests initiaux est immédiatement atténué en définissant à la fois un critère d'acceptation clair, puis en écrivant au test. Non seulement le coût des tests initiaux est atténué, mais j'ai également constaté qu'il accélère généralement le développement global. Bien que ces améliorations de vitesse puissent être annulées par une mauvaise définition de projet ou des exigences changeantes. Cependant, nous sommes toujours en mesure de répondre assez bien à ce genre de changements sans impact grave. ATDD réduit également considérablement les efforts des développeurs pour vérifier le comportement correct du système via sa suite de tests automatisés dans les cas suivants:

  • grands refactors
  • mises à niveau de plate-forme / package
  • migration de plateforme
  • mises à niveau de la chaîne d'outils

Cela suppose une équipe qui connaît le processus et les pratiques impliqués.

Implication du client

Combien d'efforts supplémentaires de la part du client?

Ils doivent être beaucoup plus impliqués sur une base continue. J'ai vu une énorme réduction de l'investissement initial, mais une demande beaucoup plus importante en cours. Je n'ai pas mesuré, mais je suis assez certain qu'il s'agit d'un investissement en temps plus important pour le client.

Cependant, j'ai trouvé que la relation client s'améliore considérablement après environ 5 démos où ils voient leur logiciel prendre lentement forme. L'engagement de temps du client diminue quelque peu au fil du temps à mesure qu'un rapport se développe, tout le monde s'habitue au processus et aux attentes impliquées.

Estimation du projet

J'imagine que les estimations de temps seraient très vagues dans un processus TDD itératif au début d'un projet TDD (car il n'y a pas de plan de développement logiciel).

J'ai trouvé que c'est généralement une question de savoir dans quelle mesure la demande est bien définie et si le (s) responsable (s) technique (s) sont en mesure de distribuer (y compris l'estimation de la carte) le projet. En supposant que le projet est bien documenté et que vous avez une moyenne de vitesse raisonnable et un écart-type, nous avons trouvé qu'il est facile d'obtenir une estimation décente. Évidemment, plus le projet est grand, plus il y a d'incertitude, c'est pourquoi je divise généralement un grand projet en un petit projet avec la promesse de continuer plus tard. C'est beaucoup plus facile à faire une fois que vous avez établi un rapport avec le client.

Par exemple:

Les "sprints" de mon équipe durent une semaine et nous avons une moyenne courante et std. écart des 14 dernières semaines. Si le projet est de 120 points, nous avons une moyenne de 25 et un std. la déviation de 6 estimant alors l'achèvement d'un projet est:

Project Total / (Mean Velocity - (2 * Std. Deviation) = 95% Time Estimate
120           / (25            - (2 * 6             ) = 9.2 weeks

Nous utilisons le 2 Std. Règle d'or de l'écart pour notre estimation de confiance à 95%. Dans la pratique, nous terminons généralement le projet sous la première norme. écart, mais sur notre moyenne. Cela est généralement dû à des améliorations, des changements, etc.


Donc, fondamentalement, ce que vous dites, c'est que TDD améliore l'effort de développement en encourageant les parties prenantes à faire les choses qu'elles devraient de toute façon faire, comme fournir des exigences claires et exploitables et des critères d'acceptation.
Robert Harvey

1
Eh bien, pas seulement ça. À mesure que le projet progresse, la participation accrue permet une meilleure conversation entre le développeur et les parties prenantes. Cela permet des choses comme les développeurs proposant des alternatives moins coûteuses à mesure que leur compréhension de ce que veut la partie prenante s'affine. Il permet aux parties prenantes de modifier les exigences plus tôt lorsqu'elles se rendent compte que les choses manquent ou ne fonctionneront pas sans une telle réaction antagoniste de la part des développeurs; et sans beaucoup des attentes déraisonnables qui viennent habituellement des parties prenantes.
dietbuddha du

-1

exiger des tests à l'avance semble nécessiter davantage d'heures de développement pour les développeurs. Dans quelle mesure l'effort de développement augmente-t-il ou diminue-t-il réellement en raison de l'élimination immédiate des bogues?

Ce n'est en fait pas vrai. Si vos développeurs écrivent des tests unitaires (et ils le devraient), le temps devrait être approximativement le même, ou mieux. J'ai dit mieux, car votre code sera entièrement testé, et ils ne devront écrire que le code pour répondre aux exigences.

Le problème avec les développeurs est qu'ils ont tendance à implémenter même des choses qui ne sont pas nécessaires pour rendre le logiciel aussi générique que possible.

Combien d'efforts supplémentaires de la part du client? Doivent-ils changer la façon dont ils se rapportent au projet, surtout s'ils sont habitués au gros design dès le départ? Le nombre d'heures requis du client augmente-t-il globalement ou diminue-t-il réellement?

Cela ne devrait pas avoir d'importance. Quiconque remplit les conditions doit le faire aussi bien que possible.

Si vous faites un développement agile, cela ne signifie pas pour autant un grand design. Mais, meilleures sont les exigences, l'architecture et la conception - la qualité du code augmentera et le temps de terminer le logiciel diminuera.

Par conséquent, s'ils aiment faire des BDUF, laissez-les le faire. Cela vous facilitera la vie en tant que développeur.


1
Si je comprends bien, TDD et BDUF ne sont généralement pas compatibles entre eux.
Robert Harvey

3
BDUF n'est généralement pas compatible avec de bonnes pratiques de gestion du développement. Mais il serait possible de faire un projet BDUF de façon TDD. TDD est une technique pour créer des logiciels de meilleure qualité tandis que BDUF est une technique pour la définition des exigences. Une mauvaise technique, mais une technique quand même.
Stephen

@RobertHarvey Oui, mais s'ils veulent faire du BDUF - c'est leur choix. Si vous faites vraiment de l'agilité, vous êtes libre d'améliorer leur conception et de continuer à faire du TDD.
BЈовић

vous dites donc que si j'écris un test unitaire, mon code sera complètement testé et si tous les tests réussissent, cela signifie bien sûr que le logiciel est exempt de bogues (ou du moins mieux). J'ai donc juste besoin de tester chaque méthode de mon logiciel, par exemple "fonction testSqr () {int a = 3; assertTrue (mySqr (a) == 9);} function mySqr (int a) {return 9;}"
Dainius

@Dainius Non, relisez. La couverture à 100% du code n'est pas exempte de bogues. Oui, vous devez tester individuellement chaque méthode. Bien sûr, les tests unitaires d'accès à la base de données, à l'interface graphique, etc. n'ont aucun sens. Les tests unitaires ne sont pas pour ceux-là.
BЈовић
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.