62 votes

Aidez-moi à comprendre le fonctionnement de l'assurance qualité dans Scrum.

Apparemment, nous utilisons la méthodologie de développement Scrum. Voici comment ça se passe en général :

Les développeurs se démènent pour essayer d'accomplir leurs tâches. En général, les tâches prennent la majeure partie du sprint pour être achevées. L'AQ harcèle les développeurs pour qu'ils publient quelque chose qu'ils puissent tester, les développeurs finissent par envoyer un code bogué à l'AQ un jour ou deux avant la fin du sprint et passent le reste du temps à corriger les bogues que l'AQ trouve. L'AQ ne peut jamais terminer les tâches à temps, les sprints sont rarement publiables à temps, et Dev et l'AQ passent quelques jours misérables à la fin du sprint.

Comment scrum est censé fonctionner lorsque des tâches de développement publiables occupent la majeure partie du sprint ?

Merci à tous pour votre participation à la discussion. Comme il s'agit d'une question assez ouverte, il ne semble pas y avoir de "réponse" unique - il y a beaucoup de bonnes suggestions ci-dessous. Je vais tenter de résumer certains des points que j'ai retenus et d'apporter quelques clarifications.

(BTW - Est-ce le meilleur endroit pour poser cette question ou aurais-je dû la poser dans une "réponse" ?)

Points à méditer/agir :

  • Il faut veiller à ce que les tâches des développeurs soient aussi réduites (granulaires) que possible.
  • La durée du sprint doit être basée sur la durée moyenne des tâches (par exemple, un sprint avec des tâches d'une semaine doit durer au moins 4 semaines).
  • L'équipe (y compris l'AQ) doit s'efforcer de devenir plus précise dans ses estimations.
  • Envisagez de réaliser un sprint d'assurance qualité distinct, en parallèle mais décalé, si cela convient le mieux à l'équipe.
  • Les tests unitaires !

7voto

user3325752 Points 11

En tant que responsable de l'assurance qualité travaillant sur des projets Agile depuis deux ans et demi, il s'agit d'une question vraiment difficile et je n'ai pas encore toutes les réponses.

Je travaille au sein d'une "triplette" (deux développeurs qui programment en binôme + un AQ) et je participe à l'attribution des histoires et à l'estimation lors des réunions de planification au début des itérations de deux semaines. Comme adrianh l'a mentionné plus haut, il est essentiel que les AQ fassent entendre leur voix lors de la planification initiale du sprint. Cela peut être difficile, surtout si vous travaillez avec des développeurs à la personnalité très forte, mais les AQ doivent s'affirmer au sens propre du terme (c'est-à-dire sans agressivité ni force, mais en cherchant respectueusement à comprendre la vérité/le responsable et les développeurs/experts techniques tout en se faisant comprendre). Je préconise de produire les tâches d'assurance qualité en premier lieu lors de la planification afin d'encourager une mentalité axée sur les tests - l'assurance qualité peut avoir à se mettre littéralement en avant pour que cela soit adopté. C'est à l'opposé de la façon dont beaucoup de gens pensent que le développement de logiciels fonctionne, mais cela rapporte des dividendes pour plusieurs raisons ;

  1. L'AQ est entendue et n'est pas reléguée à la question "comment allez-vous tester cela ?" après que les développeurs ont dit leur mot (mentalité de cascade).

  2. Cela permet à l'AQ de proposer des idées de test qui, en même temps, vérifient la testabilité des critères d'acceptation, tandis que le responsable de la vérité est présent (j'ai bien dit qu'il est essentiel qu'il soit présent à la réunion de planification, n'est-ce pas ?

  3. Il constitue la base d'une approche axée sur les tests - une fois que l'approche des tests a été énoncée et que les tâches ont été définies, les développeurs peuvent réfléchir à la manière dont ils produiront le code qui passera ces tests.

  4. Si les étapes 1 à 3 sont votre seule activité TDD pour le reste de l'itération, vous faites quand même un million de fois mieux que le scénario postulé par Steve dans le premier message : "Les développeurs s'agitent en essayant d'accomplir leurs tâches. Généralement, les tâches prennent la plus grande partie du sprint à compléter. L'AQ harcèle les développeurs pour qu'ils publient quelque chose qu'ils puissent tester, les développeurs finissent par envoyer un code bogué à l'AQ un jour ou deux avant la fin du sprint et passent le reste du temps à corriger les bogues que l'AQ trouve".

Il va sans dire que cela s'accompagne de quelques réserves pour l'AQ ;

  1. Ils doivent être prêts à voir leurs idées de test remises en question par les développeurs et les responsables de la vérité et à parvenir à un compromis ; l'attitude de "police de l'assurance qualité" ne fonctionnera pas dans une équipe Agile.

  2. Les tâches d'assurance qualité doivent trouver un équilibre difficile pour n'être ni trop détaillées ni trop génériques (les tâches peuvent être écrites sur une carte pour être placées sur un "tableau radiateur" et discutées lors des réunions quotidiennes de stand up - elles doivent passer de "en cours" à "terminées" PENDANT l'itération).

  3. Les AQ doivent se préparer aux réunions de planification/estimation. Ne vous attendez pas à pouvoir vous présenter et produire une approche de test de but en blanc pour des histoires d'utilisateurs inconnues ! Les développeurs semblent pouvoir le faire parce que leurs tâches sont souvent beaucoup plus claires - par exemple, "changer le module x pour qu'il s'interface avec le composant z" ou "remanier la méthode y". En tant qu'AQ, vous devez vous familiariser avec la fonctionnalité introduite/modifiée AVANT de planifier afin de connaître la portée des tests et les techniques de conception des tests que vous pourriez appliquer.

  4. Il est presque essentiel d'automatiser vos tests et de les avoir écrits et "échoués" dans les deux ou trois premiers jours d'une itération ou au moins pour coïncider avec le moment où les développeurs ont le code prêt. Vous pouvez alors exécuter le(s) test(s) et voir s'il(s) passe(nt) comme prévu (AQ TDD correcte). C'est ainsi que vous évitez une mini-cascade à la fin des itérations. Vous devriez vraiment faire une démonstration du test aux développeurs avant ou pendant qu'ils commencent à coder, afin qu'ils sachent ce qu'ils doivent viser.

  5. Je dis que 4 est "presque essentiel" parce que la même chose peut parfois être réalisée avec succès avec des listes de contrôle manuelles (j'ose dire scripts !) du comportement attendu - la clé est de partager cela avec les développeurs à l'avance ; continuez à leur parler !

En ce qui concerne le point 2 ci-dessus sur le sujet des tâches, j'ai essayé de créer des tâches aussi granulaires qu'une demi-heure à 2 heures, chacune correspondant à un élément de travail démontrable, par exemple "Ajouter des vérifications pour le mot de passe incorrect au test automatique - 2 heures". Bien que cela m'aide à organiser mon travail, les autres membres de l'équipe m'ont reproché d'être trop détaillé et, lors des réunions, j'ai soit déplacé plusieurs tâches de la veille pour les terminer, soit été incapable de déplacer des tâches parce que je ne les avais pas encore commencées. Il est donc plus utile de créer des tâches par blocs d'une demi-journée ou d'une journée (mais vous pouvez conserver votre propre liste de "micro-tâches" à réaliser en vue de l'achèvement des tâches plus importantes, que vous utilisez pour COMMUNIQUER les progrès globaux lors du stand-up).

En ce qui concerne les points 4 et 5 ci-dessus, les tests automatisés ou les listes de contrôle manuelles que vous préparez en amont ne devraient couvrir que les chemins heureux ou les critères d'acceptation clés. Une fois que ceux-ci sont passés, vous pouvez avoir prévu une tâche supplémentaire pour une dernière série de "tests exploratoires" vers la fin de l'itération pour vérifier les cas limites. Ce que les développeurs font pendant ce temps est problématique car, en ce qui les concerne, le code est "complet" à moins que et jusqu'à ce que vous trouviez un bug. Certains praticiens Agile préconisent d'aller pour les cas limites d'abord, mais cela peut aussi être problématique parce que si vous manquez de temps, vous pouvez ne pas avoir assuré que les critères d'acceptation ont été livrés. Il s'agit d'une de ces décisions finement équilibrées qui dépendent du contexte de l'histoire de l'utilisateur et de votre expérience en tant qu'AQ !

Comme je l'ai dit au début, je n'ai pas encore toutes les réponses, mais j'espère que ce qui précède vous donnera quelques conseils issus d'une expérience difficile !

5voto

Kurt Pattyn Points 1650

Nous avons résolu ce problème comme suit : - Chaque élément du backlog de produit doit avoir des critères d'ajustement ou d'acceptation, Sans ces critères, nous ne pouvons pas commencer un sprint. - Un testeur fait partie de notre équipe, pour chaque élément du backlog de produit, il crée des tâches de test (1 ou plusieurs, en fonction des critères d'acceptation) avec une estimation et un lien vers l'élément à tester. - Pendant la mêlée quotidienne, toutes les tâches qui sont terminées sont placées dans une colonne "à tester". - Nous ne faisons jamais de tâches qui prennent plus de 16 heures ; les tâches dont l'estimation est plus longue sont divisées.

4voto

Mark Bessey Points 13931

Il semble que votre équipe de développement ne fasse pas assez de tests de son côté, avant de passer à l'assurance qualité. Si tous vos tests unitaires passent, le cycle d'assurance qualité devrait se dérouler relativement facilement, non ? Ils trouveront bien quelques erreurs d'intégration, mais il ne devrait pas y en avoir beaucoup, non ?

4voto

Mark Points 6505

Je pense qu'il y a plusieurs problèmes ici. Tout d'abord, je pense que les tâches des développeurs ne sont peut-être pas assez précises, ou peut-être pas bien estimées, ou peut-être les deux. L'objectif des sprints dans Scrum est d'être capable de démontrer un code fonctionnel à la fin des sprints. Les deux problèmes que j'ai mentionnés peuvent conduire à un code bogué.

Si les développeurs publient du code bogué vers la fin du sprint, je me pencherais également sur la question :

  • Les propriétaires du produit tiennent-ils vraiment les membres du développement responsables de l'exécution de leurs tâches ? C'est le travail du PO et si ce n'est pas le cas, les développeurs se relâcheront.
  • Les développeurs utilisent-ils une sorte de TDD ? Si ce n'est pas le cas, cela peut être très utile. Faites en sorte que les développeurs prennent l'habitude de tester leur code. Nous avons ce problème là où je travaille, et mon équipe se concentre sur le TDD dans les domaines importants afin de ne pas avoir à demander à quelqu'un d'autre de le faire plus tard.
  • Les histoires de tâches/utilisateurs sont-elles trop génériques ? Une marge de manœuvre dans la répartition des tâches incitera les développeurs à être négligents. Encore une fois, il s'agit en quelque sorte d'un problème de PO.

Une idée que j'ai entendue dans le passé est d'utiliser une personne chargée de l'assurance qualité comme scrummaster. Il sera présent lors des réunions quotidiennes et pourra savoir où en sont les choses avec les développeurs. Il peut aborder les problèmes avec le PO (en supposant que le PO puisse faire son travail de manière adéquate).

Je ne peux m'empêcher de penser que vous avez besoin de plus de cohésion entre l'AQ et vos équipes de mêlée. Il semble que les tests n'interviennent qu'à la fin, ce qui est un problème. Faire en sorte que l'AQ fasse partie de l'équipe aidera à identifier les choses qui peuvent être testées plus tôt et mieux.

J'ai aussi l'impression que vous avez un problème avec le propriétaire du produit. Il doit être là pour s'assurer que tout le monde va dans la bonne direction. Il doit s'assurer qu'il y a une bonne coopération, non seulement entre l'AQ et les développeurs, mais aussi entre les développeurs eux-mêmes.

4voto

adrianh Points 1471

"Comment scrum est-il censé fonctionner lorsque le Dev est libérable ? prennent la majeure partie du sprint ?"

Comme vous l'avez découvert, cela ne fonctionne pas très bien :-) Le processus que vous décrivez ne ressemble pas beaucoup à Scrum pour moi - ou du moins pas à Scrum bien fait.

D'après ce que vous avez décrit, je ne sais pas si les responsables de l'assurance qualité font partie de l'équipe ou s'ils constituent un groupe distinct.

S'il s'agit d'un groupe distinct, c'est probablement une grande partie du problème. Ils ne seront pas impliqués dans l'engagement de l'équipe à l'achèvement des tâches - et la négociation associée de la portée avec le propriétaire du produit. Je n'ai jamais vu un groupe agile réussir sans qu'il y ait des compétences en AQ dans l'équipe. Soit en ayant des développeurs avec beaucoup de compétences de test/QA - ou en ayant une personne intégrée de QA ou trois dans l'équipe.

S'ils sont dans l'équipe, ils doivent faire entendre leur voix davantage lors de la planification initiale du sprint. Il devrait maintenant être clair pour le propriétaire du produit et l'équipe que vous vous engagez trop.

J'essaierais quelques trucs si c'était moi :

  • Intégrez des personnes chargées de l'assurance qualité et des tests dans l'équipe, si ce n'est pas déjà le cas.
  • Ayez une longue discussion avec le propriétaire du produit et l'équipe sur ce qui est considéré comme "fait". Il semble que certains développeurs soient encore dans l'état d'esprit d'avant la crise : "remis à l'AQ" = terminé.
  • Découpez les histoires en petits morceaux - il est plus facile de repérer les erreurs d'estimation.
  • Envisagez d'effectuer des sprints plus courts - car il est plus facile de suivre et de tirer des enseignements d'un petit nombre de sprints plus fréquents.

Vous pouvez également trouver ces conseils sur le lissage d'un burndown de mêlée utile.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X