Amis

Accueil‎ > ‎

Bien démarrer avec "Scrum"

Mis à jour en juin 2009

Scrum (« Mêlée » en Rugby) est l'une des méthodes Agile les plus éprouvées. Expérimentée depuis 1993 elle bénéficie aujourd'hui de nombreux retours d'expérience positifs provenant d'un peu partout dans le monde (notamment de Nokia, Yahoo et Google). Les séminaires, les outils et ouvrages autour de cette méthode se multiplient. Scrum repose sur l'empirisme, le pragmatisme et la transparence.

Elle vise à donner un cadre (ou framework) s'adressant à la gestion d'un projet. La méthode Agile « XP » (eXtreme Programming) vient compléter le vide laissé par Scrum en matière de pratiques de développement (programmation en binôme, développement piloté par les tests, intégration continue, etc). Ces deux méthodes combinées permettent de mieux garantir la conformité du produit par rapport aux attentes des utilisateurs finaux, une meilleure qualité des développements voir une meilleure productivité. Il est cependant important de rappeler que XP couvre également efficacement les aspects "gestion de projet" faisant d'elle une des méthodes Agile les plus complète.

Cet article décrit le processus (ou cycle) Scrum, ses étapes, les réunions, les rôles, etc. J'ai essayé d'être suffisamment complet pour en faire un Quick Start Scrum (avec une pincée d'XP) mais je vous invite à basculer sur l'ouvrage "Scrum depuis les tranchées" (gratuit, complet et traduit en français) dès que vous atteignez les limites de ce document.

Pour cet article, il est inutile de chercher à distinguer les termes "exigence", "fonctionnalité" et "histoire d'utilisateur" (user story) même si dans la réalité les définitions diffèrent sensiblement.




Utilisation de Scrum

Pré requis

  • Paper board
  • Un grand mur libre et dégagé dans l'espace de travail de l'équipe (ou très proche au pire)
  • Blocs de post-it de différentes couleurs
  • L'ouvrage "Scrum depuis les tranchées" (traduit en français et gratuit)
  • Jeu de cartes ou logiciel de Planning Poker
  • Optionnel : Un logiciel « Scrum » (ex : ScrumWorks, Rally, IceScrum, JIRA + GreenHopper, Trac + plugin, ...)
De plus pour mémoire je rappelle le cycle de vie d'un projet Scrum (schéma largement diffusé) :


Vision du projet et product backlog

Avant toute chose, il est primordial de partager avec le client la vision du projet (objectifs, jalons, attentes des utilisateurs finaux, bénéfices attendus,...). Vous devez ensuite établir la liste des principales fonctionnalités attendues par le client. Sans essayer d'être forcément exhaustif et sans rentrer dans le détail de chaque fonctionnalité. Si un cahier des charges existe déjà, il peut vous servir de base mais rien ne vaut une bonne réunion interactive (surtout si vous travaillez pour la première fois avec ce client. Après tout il faut bien faire connaissance). 

Une fois que cette liste est constituée, il faut la prioriser en fonction de la valeur métier (ou importance métier du point de vue client) et du coût de chaque élément. L'approche la plus simple consiste à pondérer chaque fonctionnalité avec un niveau d'importance. "haute", "moyenne" ou "faible" par exemple ou encore avec des points selon la suite de Fibonacci. Par la suite, les fonctionnalités les plus importantes pour le client (en tête de liste) seront implémentées en premier. La liste pourra être modifiée/complétée tout au long du projet, elle constitue le "Product Backlog". 

Par ailleurs, vous devez identifier dans l'équipe client (ou MOA/AMOA) le "Product Owner" ou "responsable du produit". Cette personne devra s'approprier et maintenir à jour le product backlog tout au long du projet, être l'interlocuteur privilégié de votre équipe,...

Estimations

L'ensemble des fonctionnalités de la liste doivent être estimées par l'équipe après avoir été transcrites en histoires d'utilisateur (voir § Rédaction d'une exigence fonctionnelle en "Histoire d'utilisateur" en annexe). Le planning poker est un excellent outil en la matière. Il permet d'estimer relativement rapidement, avec précision en impliquant plusieurs membres de l'équipe. Avant ou pendant les estimations, le Product Owner sera peut être sollicité pour répondre aux questions de l'équipe. A ce stade vous approfondirez un peu plus le besoin, mais sans aller trop loin (il s'agit simplement d'estimer le coût de chaque exigence). Au bout de quelques séances de planning poker, vous disposerez ainsi de l'ensemble des estimations en points et d'un montant total convertible en jours hommes. Vous obtenez ainsi une bonne estimation de la charge totale du projet.

Démarrage

Vous pouvez commencer par déterminer en accord avec le client la durée d'une itération ou Sprint (en général de 2 à 4 semaines). Vous devrez vous tenir à cette durée.

Un projet démarre généralement (mais pas forcément) par ce qu'on appelle souvent le "Sprint 0" dédié aux travaux préparatoires du projet (ex : préparation des environnements, mise en place de l'intégration continue, définition de l'architecture générale du projet au besoin, formalisation des exigences fonctionnelles et non fonctionnelles,...). Exceptionnellement, la durée de ce "Sprint 0" ne respecte pas forcément la durée fixée précédemment.

Réunion de planification de l'itération (environ 2h)

Ou "Sprint Planning Meeting".
Fréquence : à chaque début d'itération

Une fois que le Product Backlog est suffisamment complet et priorisé pour lancer une itération (ou sprint), les festivités démarrent. La réunion de planification d'une itération permet de définir un plan détaillé de celle ci. Le Product Owner revoit alors avec l'équipe la vision du projet, la roadmap, le plan de livraison (jalons et deadline) et le Product Backlog.
L'équipe vérifie les estimations, confirme qu'elles sont exactes et estime sa capacité à faire (capacité de travail de l'équipe sur l'itération en fonction du nombre de développeurs et du nombre d'heures pressenti).

Exemple de calcul de la cpacité à faire


 Durée de l'itération (ou Sprint)  2 semaines
 Jours de travail durant l'itération  10 jours

 Membre de l'équipe
 Nb jours travaillés durant l'itération
 Nb d'heure de travail pur par jour
 Nb total d'heure de travail pur par itération
 David  9 jours
 4 heures
 36 heures
 Mohamed  10 jours
 5 heures
 50 heures
 Marc  10 jours
 4 heures
 40 heures
 Jérôme  8 jours
 5 heures
 40 heures

Il ne reste plus qu'à faire le total en heure. 

N.B : Sur une journée de 8 heures, tout le monde ne passe pas tout son temps à développer, il faut donc déduire le temps passé sur les autres activités.

L'équipe prend ensuite les premiers éléments du Product Backlog réalisables d'ici la fin de l'itération. Puis découpe chaque élément sélectionné en tâches du Sprint afin de former le « Sprint Backlog ». Ces tâches ne font pas plus de 2 jours en moyenne (soit 16h) sauf cas exceptionnels. Si la somme des tâches en termes de coût est beaucoup plus élevée que la première estimation (celle de l'histoire d'utilisateur mère issue du product backlog), l'équipe négocie avec le « product owner » la quantité de fonctionnalités à réaliser durant le sprint afin de garantir la livraison d'un produit potentiellement utilisable. Si le découpage en tâche prend trop de temps en séance, il est possible de découper qu'une partie puis le reste au fil de l'eau.

Le tableau des tâches mural peut maintenant être rempli de la façon suivante (chacun peut laisser libre cours à son imagination mais les colonnes "A faire", "En cours" et "Terminé" sont plutôt incontournables) :


Story = exigence (découpée en tâches pondérées en heures que l'on retrouve sur les colonnes de droite)

Sur ce tableau, les Stories sont les gros post-it larges (rose pour les Stories connues au début du projet, orange pour celles qui se sont ajoutées par la suite), les sous tâches des Stories sont en jaune, on trouve en bleu des tâches imprévues indépendantes. Au dessus du tableau figurent les obstacles courants, un graphique d'avancement et un calendrier géant avec les dates clefs et les congés de chacun. Sur la droite on trouve des maquettes d'IHM, des documents métier,...

Cette réunion de planification est l'occasion de préciser ou rappeler à l'équipe la définition de "terminé" pour une "story". Généralement, "terminé" signifie que les développements sont commités sur le gestionnaire de version, testés unitairement et que les tests d'acceptation ont été passés avec succès par le développeur.

A l'issue de cette réunion, l'équipe - qui a participé aux estimations - s'engage à faire le nécessaire pour atteindre l'objectif fixé. En cas de retard (indiqué par le Burndown Chart), des tâches seront retirée du Sprint Backlog en cours de route. Et inversement si l'équipe avance plus vite que prévu, des tâches y seront ajoutées.

Sprint (2 à 4 semaines)

Au cours du Sprint, l'équipe se concentre sur l'accomplissement des tâches du Sprint Backlog. Les développements se font verticalement et non pas horizontalement par couche (fini le temps où on développait tous les services métier, puis toutes les IHM,...). Il faut également bien sensibiliser l'équipe de façon à éviter que trop de tâches soient menées en parallèle par un même développeur (une brique après l'autre).

Le tableau physique des tâches rempli de post-it est pratiquement indispensable. Il permet d'avoir une vision claire du travail à accomplir, en cours et terminé. Il peut également s'avérer précieux lors des réunions quotidiennes (voir § suivant), surtout si vous calculez à la main le reste à faire du Sprint  afin de tracer le graphique d'avancement (voir plus loin le "Burndown Chart"). Le tableau facilite également l'affectation des tâches par l'équipe en ayant une vision d'ensemble du Sprint en un coup d'œil. Inutile de se torturer à planifier à l'avance dans le détail l'activité de chaque développeur sur toute la durée de l'itération (il faut se détacher d'une approche prédictive et des diagrammes de Gantt). 

Pas mal de choses peuvent s'ajouter au mur comme les risques et actions de réductions. 

Point(s) de vigilance

Afin de garder l'équipe concentrée sur un objectif fixe, une itération en cours ne peut intégrer d'exigence supplémentaire . En cas de force majeure, l'exigence sera ajoutée en échange du retrait d'une autre de charge de travail équivalente. Si cet imprévu implique du refactoring, le coût de ce dernier sera estimé par l'équipe et fera l'objet d'une tâche supplémentaire (si toutefois le client maintient sa demande malgré ce surcoût annoncé).

Mêlée (Scrum en anglais) quotidienne ou "stand-up meeting" (environ 15 min)

Cette réunion qui se fait debout (on traine rarement quand on doit rester debout) est très importante à la fois pour l'équipe et pour le « ScrumMaster ». Par ailleurs, elle contribue à faire naître un esprit d'équipe très précieux. Tout le monde peut participer à cette réunion mais seuls les membres de l'équipe s'étant engagés à livrer des fonctionnalités de l'itération sont autorisés à parler.

Chaque personne répond à 3 questions :

  • Qu'ai je fait depuis la dernière mêlée ?
  • Qu'est ce que je fais aujourd'hui ?
  • Quels problèmes je rencontre (m'empêchant de tenir mes engagements) ?

Cette réunion permet aux membres de l'équipe :

  • De se coordonner
  • De s'exprimer (en particulier quand ils rencontrent des problèmes)
  • De trouver de l'aide ou d'en apporter
  • De savoir qui fait quoi
  • D'éventuellement gagner du temps en partant d'un développement déjà réalisé par un autre
  • De connaître l'avancement au quotidien (en mettant à jour le Burndown Chart)

Elle permet au ScrumMaster d'être immédiatement au courant des obstacles rencontrés, il doit impérativement les prioriser, les suivre et bien sûr s'efforcer de les lever au quotidien afin de garder l'équipe concentrée et productive.

Point(s) de vigilance et conseils

  • Certaines discussions risquent de s'éterniser à l'occasion de cette réunion, c'est pourquoi il faut rester vigilant afin de respecter une durée raisonnable (15 minutes). Un chronomètre peut être utile. Ce type de conversation devra donc se dérouler après la réunion afin de ne pas mobiliser inutilement les personnes non concernées.
  • Il est souvent difficile d'avoir toute l'équipe au même moment pour cette réunion, ne décalez pas la réunion dès que quelqu'un a du retard. Convenez d'une heure avec l'équipe et essayez de vous y tenir quelques soit le nombre de personnes présentes.
  • Ne forcez pas la main à ceux qui ne veulent pas jouer le jeu, ils se rendront vite compte que des choses importantes se décident lors de ces réunions et que ces 15 minutes sont aussi l'occasion de s'intéresser au travail et aux difficultés de chacun.


Graphique d'avancement (Burndown Chart)

Pour connaître votre avancement, vous allez avoir besoin de tracer le Burndown Chart de l'itération courante. Ce graphique est simple, il s'agit du tracé du "reste à faire" en fonction du temps.

Pour tracer ce graphique, il suffit de mettre à jour (lors de chaque réunion quotidienne par exemple) le tableau suivant :

 Tâche  Propriétaire  Jour 1
 Jour 2  Jour 3  Jour 4  Jour 5  Jour 6
 Jour 7
 ...
 Configurer la base de données
 David  4  4  3  1  0      
 Implémenter le détail d'un article
 Mohamed  3  3  5  2  0      
 Ajouter le HTTPS sur les transactions
 Marc  2  2  2  2  2      
   ...  ... ...
...
...
...
     
   TOTAL  50  48  44  43  34      

Les chiffres correspondent au nombre d'heures (ou jours) de travail restant sur chaque jour de l'itération.

La courbe peut parfois augmenter ponctuellement pour différentes raisons :

  • Mauvaise estimation de la charge
  • Ajout de fonctionnalités par le Product Owner
  • Ajout d'anomalies costauds à corriger
  • ...

Voici un exemple :



Vous pouvez éventuellement tracer un Burndown Chart global indiquant le "reste à faire" de l'ensemble du projet en actualisant le graphique à la fin de chaque itération.
De cette façon, vous disposez d'indicateurs simples à calculer qui devraient satisfaire votre client et votre responsable.

Réunion de démonstration (environ 2h)

Fréquence : A la fin de chaque itération


L'objectif de la démonstration n'est pas de trouver des bug mais de détecter en amont les éventuelles mauvaises interprétations du besoin. Pour le client, c'est l'occasion de prendre conscience de votre avancement, de se rassurer ou d'être plus précis dans l'expression de son besoin voir plus impliqué (parfois le client tarde à prendre certaines décisions importantes pour vous). Les feedbacks sont les bienvenus.

Il ne s'agit pas d'une présentation, pas de power point, seules 30 minutes de préparation au maximum sont nécessaires. Un simple PC de développement peut faire l'affaire. Idéalement, le Product Owner peut orienter la démonstration selon ses souhaits voir prendre la souris. Les autres intervenants du projet peuvent également être conviés. Les aspects aussi bien métiers que techniques peuvent être abordés.

Le Product Owner détermine quelles fonctionnalités on été terminées durant l'itération et échange avec l'équipe et autres intervenants afin d'éventuellement re-prioriser au mieux le « product backlog ». A l'issue de cet échange, l'objectif du prochain Sprint peut être définit.

La démonstration n'implique pas forcément une livraison, il est cependant recommandé de réaliser des livraisons régulièrement (toutes les 1, 2 ou 3 Sprints selon les contraintes du projet). Cela permet au client et ses utilisateurs finaux de pousser un peu plus loin leurs tests, d'anticiper d'éventuels problèmes de fond, voir de mettre en production plus tôt que prévu l'application partielle dégageant ainsi un premier retour sur investissement. Sur un plan technique, ces livraisons permettent aussi de valider l'architecture technique cible, d'essuyer les plâtres sur le processus de livraison, d'exploitation de l'application, de gestion des environnements,...

Réunion de rétrospective (environ 2h)

Fréquence : A la fin de chaque itération


Cette seconde partie est animée par le « ScrumMaster » qui s'adresse à son équipe. Elle a pour but d'améliorer continuellement la productivité de l'équipe en mettant les idées de chacun à contribution.

On se concentre essentiellement sur :

  • La façon dont l'équipe a travaillé de concert
  • Encouragement des aspects positifs de ce travail collaboratif pour la suite
  • Identification de ce qui peut être amélioré, élaboration de stratégies d'amélioration en accord avec l'ensemble de l'équipe

Un bon exercice consiste à utiliser le paper board et séparer l'espace en deux colonnes à remplir : une colonne « Qu'est ce qui a bien fonctionné ? » et « Qu'est ce qui ne va pas ou peut être amélioré ? ». Chacun à tour de rôle remplit les colonnes et lorsqu'un élément est déjà identifié on ajoute un « bâton » en face. Ensuite il ne reste plus qu'à réfléchir ensemble aux solutions d'amélioration de la productivité de l'équipe. Ces solutions concrètes d'amélioration constituent le plan d'actions (fruit de la réunion).

Projet Scrum et vieilles habitudes MOA/MOE

Il est important de prendre conscience que les méthodes Agile ne considèrent pas de séparation MOA/MOE (typiquement française empruntée à tort au secteur du BTP).
Il est donc primordial de décloisonner au maximum MOA et MOE, ces deux entités doivent collaborer étroitement tout au long du projet. Etant donné que l'on touche ici à des habitudes bien ancrées, je vais m'efforcer d'expliquer quel rôle peut jouer la MOA dans un projet Agile.

Le rôle du consultant métier

Dans le cadre d’une approche Agile, les tâches d’un profil fonctionnel peuvent rester les même que dans le cadre d’une approche traditionnelle :
  • Modélisation des processus métier
  • Participation aux ateliers de conception
  • Rédaction des tests d'acceptation (en amont des développements)
  • Vérification de la conformité des fonctionnalités (en aval des développements)
  • ...
Le changement réside dans l’organisation du travail. L’approche séquentielle propice à l’effet tunnel est remplacée par une approche itérative, le travail est donc lissé dans le temps sur toute la durée du projet. De plus, un responsable métier devra jouer le rôle clairement défini de « responsable du produit » ou "product owner".

Rôle du responsable du produit (product owner)

Le responsable du produit  est chargé de :
  • Produire ou fortement contribuer à la rédaction de la liste initiale des exigences du projet (ou histoires d'utilisateur)
  • Prioriser ces dernières en fonction de leur importance métier
  • Répondre aux attentes de l’équipe de réalisation
  • Valider une fonctionnalité "terminée"
  • Prendre des décisions importantes en temps voulu
L’équipe de réalisation s’engage faire une démonstration (voir livrer) à la fin de chaque itération ou Sprint le produit testable enrichi de nouvelles fonctionnalités.

A la fin de chaque itération, le responsable du produit peut :
  • Ajouter une exigence manquante
  • Retirer une exigence finalement inutile
  • Redéfinir la priorité des exigences

Renfort du responsable du produit (product owner)

Le « ScrumMaster » peut assister le responsable du produit afin de le familiariser avec la méthode Scrum.
L’équipe de réalisation aide le « Responsable du produit » à prioriser ses exigences en lui apportant une évaluation de leur coût.
Une équipe de consultants métier peut l’aider à différents niveaux :
  • Réponse aux questions de l’équipe de réalisation tout au long du projet, prises de décisions
  • Rédaction des tests d'acceptation
  • Remaniement des exigences à la fin de chaque itération
  • Formalisation des feedbacks à la fin de chaque itération
  • Autres sujets : logistique, conduite du changement, déploiement,…
Les utilisateurs finaux : il est recommandé de solliciter les utilisateurs finaux (à la fin de chaque itération ou à l’occasion de releases par exemple) afin de garantir la bonne couverture du besoin par le produit.

Annexes

Rédaction d'une exigence fonctionnelle en "Histoire d'utilisateur"

Une fonctionnalité peut être rédigée selon le principe de la "User Story" défini par la méthode Agile XP (eXtreme Programming).
Une "Histoire d'utilisateur" doit être :
  • Courte : une ou trois phrases environ
  • Négociable : elle peut être discutée avec l’équipe chargée de la réalisation du produit, notamment lors de l’estimation
  • Source de valeur : elle doit être porteuse d’une valeur pour le client ou l’utilisateur
  • Indépendante des autres histoires d’utilisateur (dans la mesure du possible)
  • Estimable : elle peut être estimée par l’équipe de réalisation avec un risque d’erreur faible
  • D’une taille appropriée : sa taille doit être relativement petite afin de faciliter son estimation. Elle doit pouvoir être conçue, développée et testée au sein d’une itération.

Voici un exemple d'histoire d'utilisateur dans le cadre de la réalisation d'un site de vente en ligne de DVD :

 

Exemple d'histoire + tests d'acceptation

Les tests d'acceptation peuvent compléter les histoires. Communiquées aux développeurs avant que ces derniers ne débutent l'implémentation de l'exigence, ils peuvent s'avérer très précieux. Cette approche permet d'éviter les mauvaises interprétations du besoin par le développeur. On élimine ainsi dans l'œuf des anomalies potentielles, garantissant davantage de qualité.

Voici un exemple proposé par Claude Aubry dans le cadre de la réalisation d'un outil collaboratif de gestion de tâches :

Titre de l'histoire : Prendre une tâche
Détail de l'histoire : En tant que participant avec un rôle sur le projet, je prends une tâche à faire, afin de collaborer à la réussite du projet

Test associés :

1- rôle concordant

Etant donné la tâche "Analyser dans le projet P", tâche qui est libre, et le rôle Analyste joué par le participant Paulo sur P
Quand Paulo prend la tâche Analyser
Alors la tâche Analyser lui est associée

2 - rôle incohérent

Etant donné la tâche Analyser dans le projet P, tâche qui est libre, et le rôle Concepteur joué par le participant Pierrot sur P
Quand Pierrot prend la tâche Analyser,
Alors la tâche ne lui est pas associée et un message lui explique qu'il son rôle ne lui donne pas droit à cette tâche

3 - tâche déjà prise

Etant donné la tâche Analyser dans le projet P, tâche qui est déjà prise, et le rôle Analyste joué par le participant Paulo sur P
Quand Paulo prend la tâche Analyser...
Alors la tâche Analyser ne lui est pas associée et un message lui explique qu'il ne peut pas prendre une tâche déjà prise.

Quid des spécifications ?

La conception fonctionnelle voir technique d'une fonctionnalité se fait au fil de l'eau dans chaque itération. Ce n'est qu'au moment où on s'apprête à l'implémenter qu'on rentre dans les détails du besoin (pour rappel, le besoin lié à cette fonctionnalité à été abordé dans les grandes lignes lors de la phase amont d'estimation). Cette approche a le mérite de permettre au client d'ajuster ou approfondir son besoin sur les fonctionnalités implémentées plus tard. Elle lui permet aussi (ainsi qu'à l'équipe) de retarder certaines décisions sans risque pour le projet (c'est souvent plus sage quand on manque de visibilité).

XP considère que les "histoires d'utilisateur", les tests associé et le code source constituent les spécifications fonctionnelles du projet. D'autres méthodes vont plutôt préconiser la rédaction de cas d'utilisation avec un niveau de détail variable selon le contexte du projet, les exigences du client et la complexité de la fonctionnalité à spécifier.

Il faut bien comprendre que rédiger des spécifications ultra détaillées n'a de sens que dans une approche traditionnelle. Car dans ce cas de figure, le client ne verra son produit qu'à la fin des développements. Il doit donc avoir une vision précise de ce qu'il aura en fin de projet grâce aux spécifications détaillées. Or l'approche Agile apporte au client une visibilité sur le produit dès le début du projet ainsi qu'une possibilité d'ajustement du besoin. On privilégie donc le développement de l'application à une documentation exhaustive et pléthorique (d'ailleurs souvent indigeste pour le client qui tarde à valider et retarde ainsi son propre projet).

Pour la partie technique on peut souvent se limiter à un dossier d'architecture, un modèle conceptuel de données (voir physique), aux commentaires du code (Javadoc) et à une spécification détaillant les modules éventuellement complexes pour faciliter la maintenance du produit par la suite.

En appliquant ce principe, on assiste généralement à un gain de productivité par rapport à une approche traditionnelle, puisqu'on ne perd pas un temps considérable en rédaction, validation puis mises à jour de spécifications détaillées. Il est sans doute bon de préciser également que l'on ne néglige pas la conception du produit pour autant. La conception fait partie des tâches sous-jacentes à la réalisation d'une fonctionnalité.


Č
Ċ
ď
Florent Lothon,
13 juin 2009 13:26