Le blog de yquenechdu

Agile : Rugby ou Alpinisme ?

SecureOne — Sat, 04 Jul 2009 00:00:00 +0200

En lisant un ouvrage sur le "lean management" de Dirk BÖSENBERG & Heinz METZEN, j'ai remarqué une similitude qui pourrait me faire penser que le terme SCRUM ne me semble pas le plus adapté aux méthodes Agile.

Je me suis souvent demandé pourquoi SCRUM, à part pour l'esprit d'équipe de la mêlée. Le rugby ne semble pas le sport le plus en relation avec mon activité quand je pratique SCRUM.

Voici une analogie provenant de l'alpinisme qui me semble plus en adéquation avec cette méthode de travail.

"Les alpinistes en tant que sportifs incarnent le mieux l'état du régime minceur. (…) Le parallèle entre les vertus de l'alpiniste et celles des principes de travail dans le régime minceur (Lean) est étonnant."

Développement des petits pas sur un terrain solide
Plus le terrain est incertain, plus les pas sont petits et assurés
Utilisation du feed-back pour guider le prochain pas
Vitesse de développement par des pas rapides et assurés
Motivation par des progrès constants

Le parallèle est bien adapté, le but à atteindre, le sommet est généralement bien identifié et défini par un besoin client. Le chemin est semé d'embûches. La météo est incertaine, changement inattendu du sens du vent, visibilité réduite, problèmes non identifiés, mauvaise anticipation, choix malencontreux…

L'auteur fait référence à Lean (orienté industrie - ouvrage de 1994 - éditions d'organisation) et non à Agile, mais en lisant l'ouvrage, j'avais du mal à penser que je pouvais faire un distinguo entre les deux termes.

Infomaki 0.1 passe en Open Source

SecureOne — Sat, 16 May 2009 22:45:00 +0200

Infomaki est un outil pour collecter les premiers retours des utilisateurs à propos de votre application. Au démarrage, il affiche chaque écran de manière individuelle et il permet de poser des questions simples aux utilisateurs. Dans le genre "où souhaiteriez-vous que se trouve le bouton de déconnexion".

Il affiche une carte de chaque page avec les clics de souris des utilisateurs, il fournit aussi sous la forme de zones de chaleur la où il y a eu le plus de clics de souris.

Infomaki a été développé par des personnes de la NYPL Labs (The New York Public Library.), et il y a quelques jours, ils ont décidé de le distribuer en open source (nécessite Ruby on Rails 2.2 +).

Une chose intéressante à propos de ce logiciel, c'est la souplesse de son utilisation pour les utilisateurs qui testent l'application. Chaque écran affiché est une évaluation propre et indépendante, ce choix permet aux utilisateurs de choisir la durée de leur participation - ils sont en mesure d'arrêter à tout moment l'évaluation.

Pour télécharger le logiciel suivre ce lien

Linshare en ligne

SecureOne — Thu, 30 Apr 2009 14:20:00 +0200

La nouvelle version de LinShare, l'application de partage de fichier est maintenant en ligne pour la phase de bêta-test.

Elle est accessible à l'adresse http://demo.linpki.org/linShare/

Compte : demo@linagora.com

passe : linagora

Je vous laisse la tester et si vous avez des idées à apporter.

La version Open source sera disponible courant mai, le temps de prendre en compte les différents retours des bêta-testeurs et corriger encore quelques petites anomalies...

Pourquoi les logiciels libres ont une convivialité médiocre, et comment les améliorer.

SecureOne — Sat, 25 Apr 2009 14:35:00 +0200

Pourquoi les logiciels libres ont une convivialité médiocre, et comment faire pour les améliorer. (première partie)

Article en deux parties, cette article est inspiré de l'article de Matthew Paul thomas (http://mpt.net.nz/archive/2008/08/01/free-software-usability), néanmoins, il n'est pas repris en l"état et je les librement adapté selon mon expérience du milieu Open Source.

Les applications Open Source et les systèmes d'exploitation sont plus utilisables aujourd'hui qu'ils ne l'étaient il y a encore quelque temps. Mais cela est dû en grande partie à la lenteur des innovations, et du faible niveau de compétition entre les projets et les éditeurs. Les principaux problèmes liés à la méthodologie de conception ne sont toujours pas résolus. Nombre de ces problèmes proviennent des projets logiciels qui sont basés sur le volontariat, pas sur le logiciel libre en particulier. Les programmes propriétaires réalisés par des "amateurs" sont souvent difficiles à utiliser pour bon nombre des mêmes raisons. Mais la façon la plus facile d'obtenir des volontaires pour contribuer à un projet de développement est de le rendre open source. Des milliers de personnes travaillent dans le développement de logiciel libre, la plupart de ses développeurs sont bénévoles. C'est donc dans le Logiciel Libre qui emploie des bénévoles pour la réalisation de logiciel que l'on rencontre le plus souvent des problèmes d'utilisation, de conception, de documentation, etc.

Cela nous donne un indice à propos de nos deux premiers problèmes. 1. La faiblesse des incitations à la facilité d'utilisation des applications. Les éditeurs de logiciels propriétaires en général font de l'argent en produisant des logiciels que les gens veulent utiliser. Cela donne une forte incitation pour le rendre plus utilisable (cela ne fonctionne pas toujours : par exemple, Microsoft et Adobe ou le logiciel devient parfois inutilisable ou sans réelle facilité d'utilisation, mais il reste dominant par le biais des effets de réseau et du marketing.)

Avec des projets basés sur le volontariat, toute incitation est beaucoup plus faible. Le nombre d'utilisateurs qui utilise le logiciel n'a rarement de lien avec un apport financier pour les développeurs, et avec les logiciels librement redistribuables, il est de toute façon quasi impossible de compter les utilisateurs qui utilisent réellement l'application. Il existe d'autres mesures incitatives - impressionner des futurs employeurs ou inclure vos logiciels dans un OS populaire.

Solutions : Mettre en place des incitations plus fortes à son utilisabilité. Par exemple, chaque année proposer un prix du design du logiciel libre pourrait aider à faire connaître et à récompenser les développeurs qui réalisent des programmes ergonomiques, avec des interfaces IHM de qualité, etc. Les éditeurs de logiciel pourraient publier des statistiques sur le nombre de leurs utilisateurs qui utilisent leurs applications, et comment ce nombre change au fil du temps. Un système de prime que les gens pourraient verser une somme d'argent en dépôt pour celui qui met en œuvre une amélioration de la convivialité. Les éditeurs peuvent choisir de ne pas distribuer uniquement que des applications "Open Source", mais aussi une variante de l'application, avec une meilleure ergonomie et des améliorations graphiques qui pourraient être un facteur de choix lors de son acquisition.

2. Peu de bons designers. Certains musiciens sont aussi de grands compositeurs, mais la plupart ne le sont pas. Certains développeurs sont aussi de grands designers, mais la plupart ne le sont pas. Développement et design de l'interface IHM sont des compétences distinctes, et des personnes compétentes dans les deux domaines à la fois sont rares. Il est donc important d'avoir des designers dédiés, mais peu de projets Logiciels Libres le font. Certains spécialistes de l'utilisabilité sont employés par des éditeurs de logiciel libre, tels que Mozilla et Canonical (ne pas s'étonner ensuite de leur popularité). Mais ils ne sont pas nombreux, et les designers bénévoles qualifiés sont encore difficiles à trouver.

Solutions : Fournir du matériel de formation accessible aux développeurs, aux concepteurs et aux bénévoles, afin d'améliorer le niveau global de la conception et du design. Encourager les communautés qui permettent de collaborer entre développeurs et spécialistes de l'ergonomie et du design. Encourager dans les projets de logiciel libre d'avoir un responsable du produit (en terme fonctionnel), un responsable du design des interfaces, un spécialiste pour rédiger l'aide en ligne, et un ingénieur qualité, ces personnes étant distincts.

Mais pourquoi y a-t-il une pénurie de bénévoles qui ont des qualités de concepteurs ou de design ? Ce qui nous amène au troisième problème.

3. Les suggestions de design ou d'ergonomie ne sont pas souvent pas les bienvenues. Le Logiciel libre a une longue et saine tradition de "show me the code". Mais lorsque quelqu'un signale un problème d'ergonomie, cette tradition se transforme en "Envoi ton patche", ce qui est inutile puisque la plupart des designers/concepteurs ne sont pas des développeurs. Trouver des spécialistes de l'utilisabilité pour obtenir de l'aide reste un sujet difficile dans le monde Open Source.

Solution: Mettre en place des processus pour que des spécialistes de l'ergonomie ou du design contribuent à des projets. Par exemple, le concepteur pourrait publier les spécifications sur le site Web du projet et invité à donner sont avis sur un blog, wiki, ou liste de diffusion. Le concepteur peut répondre avec courtoisie aux suggestions sur la conception/ergonomie/design (même les plus étranges). Le responsable du projet pourrait mettre en place une sorte d'outil de suivi pour poser des suggestions et les retours sur l'utilisation du produit. Au lieu d'un outil de suivi d'anomalie en lecture seule qui ne donne que des informations sur le code - ce qui rend plus facile à affiner, à approuver ou refuser, et de mettre des priorités (sous la forme de bénéfice pour l’application) sur la mise en œuvre des suggestions de conception de la même manière que les rapports d'anomalies.

Pourquoi les développeurs réagissent différemment aux propositions sur la facilité d'utilisation qu'aux propositions techniques ?

4.L'usuabilité est difficile à mesurer. Certaines qualités du logiciel sont facilement et précisément mesurables : elle ne fonctionne pas pour tout le monde, les performances, si une fonction est techniquement correcte, si une anomalie apparait au milieu d'une fonction, etc.

Mais ce sont les éléments les plus importants pour la qualité et pour l'adoption du logiciel qui sont les plus difficiles à mesurer : le logiciel est-il réellement utile, est qu’il rend le service attendu, son utilisation est-elle facile ou complexe, la mise à disposition des fonctions est-elle réfléchi ou simplement "entassé" dans le logiciel, est-ce qu’il ce comporte comme les gens s'y attendent, qu'elle proportion des gens réussissent à l'utiliser sans assistance, avec quelle rapidité il l'utilise, quel et le niveau de satisfaction après l'avoir utilisé, etc.

Ces qualités concernant l'interactivité avec les utilisateurs peuvent souvent être mesurées dans des tests d'utilisateur. Mais cela prend des heures ou des jours que les bénévoles ne sont pas disposés à dépenser. Les tests utilisateurs sont de qualité moyenne, prenant en compte les grands problèmes, mais en laissant les concepteurs sans preuve tangible pour persuader les développeurs de corriger les petits problèmes. Même si le problème est identifié, une solution doit être proposée et cela nécessite de nouveaux tests.

Sans test fréquent d'utilisateur, les projets communautaires comptent sur le retour d'information subjectif de personnes qui ont consacré un peu de temps et qui les adresse sur la liste de diffusion du projet. Mais ce que ces gens disent peut ne pas être représentatif de la réalité même de leur propre comportement, et encore moins du comportement des utilisateurs en général.

Solutions : Promouvoir des tests utilisateurs à petite échelle qui peuvent être réalisés par des bénévoles. Développer et promouvoir la capture d'écran, enregistrement vidéo, wideframes et d'autres logiciels qui rend les tests plus faciles à exécuter. Réaliser des tests à la fin des itérations sur des périmètres plus restreints que sur l'ensemble de l'application. Encourager les développeurs à faire confiance au retour des utilisateurs sur les résultats de tests plus que sur l'opinion des uns et des autres. Expliquer les choix de conception que les procédures de test ne peuvent pas couvrir. Expliquer vos choix et ce qui a amené à les faire.

Le manque de designer, à son tour, contribue à trois problèmes culturels dans les projets de logiciel libre.

5. Codé avant de concevoir. Le logiciel a tendance à être beaucoup plus utilisable s'il est, au moins approximativement, conçu avant que le code soit écrit. L'IHM souhaité pour une application ou pour une fonctionnalité peut affecter le modèle de données, le choix des algorithmes, l'ordre dans lequel les opérations sont effectuées, le besoin de paralléliser les opérations, le format de stockage de données sur le disque, et même l'architecture de l'application dans son ensemble. Mais faire des wireframe (maquette d'interface statique), des spécifications et des prototypes semble ennuyeux pour un développeur, pour lui tout commence au moment du codage - il se soucie de l'interface plus tard.

Mais plus il y a de code écrit, plus il est difficile de corriger un problème de conception - ce qui engendre que les développeurs, essayeront de vous convaincre qu'il y a pas de problème, que cela pourra être corrigé dans une prochaine version, que ce n'est pas réellement un problème. Et si finalement, ils le corrigent, les utilisateurs devront réapprendre à utiliser l'interface, ce qui pourrait les frustrer et les encourager à envisager des programmes concurrents.

Solution : Faire travailler en binômes un designer et un développeur quand vous voulez développer un nouveau projet ou une nouvelle fonctionnalité. Mettre en place une culture du logiciel libre ou la conception passe en premier lieu, et le code en second.

6. Trop de cuisiniers. En l'absence de designer, les nombreux participants à un projet s'efforcent de contribuer à la conception de l'IHM, de la transition entre les pages, etc., indépendamment de ce qu'ils connaissent sur le sujet. Et plusieurs personnes à la conception et à la fabrication de l'IHM conduisent à toutes sortes d'incohérences, aussi bien dans la vision que dans le détail. La qualité de la conception de l'IHM est inversement proportionnelle au nombre de designers.

Solution : Les projets doivent avoir un responsable du design, qui prend en compte les différentes suggestions, et travaille avec les développeurs pour décider de ce qui est réalisable. Plus les spécifications seront détaillées et les grandes lignes directrices connues plus elles réduisent les erreurs potentielles durant la phase de développements.

7. Oubliez les idées préconçues. En l'absence d'une conception précise du designer qui donne son identité au logiciel, de nombreux développeurs pensent que ce que fait Microsoft ou Apple est la bonne manière de faire du design. Parfois, cela est vrai, mais parfois ce ne l'est pas. En imitant les mêmes desseins, les développeurs de Logiciels Libres répètent les mêmes erreurs, ils pérennisent ainsi l’idée qu'il n'y pas de meilleurs modèles que les solutions propriétaires.

Solution : Encourager le design innovant par le biais de prix et autres formes de publicité. Mettre à jour les guides du designer, le cas échéant, tenir compte des expériences de conception réussie.

Les autres raisons de l'existence de mauvaise ergonomie/design/convivialité indépendamment de la présence de designer.

Gratter où ça gratte. Les développeurs bénévoles travaillent sur des projets et des fonctionnalités qui les intéressent, ce qui signifie habituellement qu’ils vont utiliser le logiciel pour leur propre besoin. Ils sont les développeurs, mais également les utilisateurs. Un logiciel qui est censé avoir un périmètre à usage général finit par trop souvent devenir spécifique, complexe et très geek. Les fonctionnalités nécessaires pour les novices ou les non-techniques - tels que l'assistant de configuration, l'outil de reporting, la configuration du profil - sera négligé ou voir totalement inexistant. (Je ne vous parle de la documentation...)

Solutions : Mettre en place une culture de la simplicité, en mettant en place des design très légers, ne pas ajouter des ergonomies ridiculement complexes (compter le nombre de clic et de transition, pour chercher à les réduire systématiquement par deux), appliquer la règle des 80/20 dans la présentation des fonctions. Encourager les volontaires et les développeurs à demander à leurs amis et leurs familles d'utiliser le logiciel, s'inspirer des problèmes (pour ne pas les refaire) que les autres applications peuvent avoir quand vous les utilisez. (un exemple sur mon blog, le bouton ajouté est en haut, le bouton validé est en bas de la page, je suis obligé de faire tout défiler pour valider un nouvel ajout)

8.Laisser les idées se flétrir. Beaucoup de petits détails qui améliorent l'interface de l'application ne sont pas passionnants à réaliser. Les détails comme la création d'une fenêtre de taille plus appropriée et sa position à sa première apparition, un focus sur un contrôle précis par défaut quand une fenêtre s'ouvre, affiner les messages d'erreur et un autre texte qui peut améliorer la compréhension, ou faire une barre de progression qui refléter plus fidèlement les progrès d'ensemble. Parce que ces choses ne sont pas passionnantes ou satisfaisantes, les années passent souvent avant qu'elles ne soient corrigées. Cela donne aux utilisateurs une impression générale de mauvaise conception (et un rejet de l'application), et qui à son tour, peut décourager les spécialistes de l'utilisabilité/ergonomie de contribuer aux projets.

Solution : Lors de la planification des corrections d'anomalies, prendre en compte combien de temps ils vont prendre, éventuellement, planifier rapidement les corrections mineures, ainsi les corrections sont corrigées vélocement. Faire participer les concepteurs d'interfaces dans ce calendrier, pour se prémunir contre les défauts de la facilité, "c'est juste une question d'UI".

9. Apaiser les personnes avec des options. Dans tous les projets avec des contributeurs multiples, il arrive parfois que tout le monde ne soit pas d'accord sur des questions de conception. Lorsque les participants sont des salariés, généralement ils continuer à travailler, même s'ils sont en désaccord avec la conception. Mais avec des bénévoles, il est beaucoup plus probable que le mainteneur du projet accorde pour apaiser un contributeur d'ajouter un paramètre de configuration pour un comportement spécifique. Le nombre, l'obscurité, et la trivialité de ces préférences finissent par perdre les utilisateurs ordinaires.

Solution : les responsables des projets doivent avoir une culture de la simplicité (du 80/20). Il faut orienter le développement sous une forme modulaire (par composant), pour pouvoir retirer facilement une fonction, des options qui ne sont pas nécessaires à tous et permettent d'alléger l'interface. Diffusé le code peut aider à calmer la pression, en permettant d'adapter le code pour retirer des options qui ne sont pas nécessaires ou pour proposer des variantes du logiciel avec le comportement qu'ils veulent.

Des outils pour faire ses maquettes IHM

SecureOne — Tue, 10 Mar 2009 22:54:00 +0100

Un petit billet pour vous présenter deux applications Open source pour créer vos maquettes d'IHM Web ou de vos applications lourdes.

Les maquettes sont des représentations statiques d’une page d’un site ou d’une application. On doit y formaliser les éléments présents, leur taille approximative, leur localisation, leur appellation… Les maquettes peuvent aussi concerner un élément plus précis de l’interface (par exemple la représentation des différents états d’une partie de la page). Là encore, le choix de l’application devra se faire en fonction du niveau de fidélité visuelle que l’on veut obtenir et de l’objectif que l’on vise (présentation à un client, document de travail, support d’un test utilisateur, etc.).

La première application permet de réaliser des drafts de maquettes, nous sommes plus proche de l'état de brouillon que de maquettes client. Idéal pour les brainstormings ou les spécifications internes. On peut l'utiliser pour travailler rapidement avec son équipe, hors d'un contexte client.

La première application est Denim (Université de Berkeley), elle a l'avantage d'être gratuite et peut-être déployée sur son poste de travail. Elle est compatible avec les trois OS (Linux, Mac, Windows)

Denim se base sur un concept intéressant : conserver les avantages du prototypage papier, tout en y introduisant des notions d’interactivité : elle permet de lier chacune des pages de façon dynamique (on se dirige là dans des problématiques de prototypage). Idée intéressante pour nos projets en méthode Agile.

L’utilisabilité de l’application est discutable, il est au premier abord assez difficile de se familiariser avec l’accès et le comportement du menu. De plus, l’utilisation de Denim en tant qu’outil de travail est presque soumise à l’emploi d’une palette graphique.

Toutefois après quelques bonnes dizaines de minutes d'utilisation, on commence à se familiariser, le menu est particulier au premier abord, mais intelligent quand on commence à saisir le concept.

Une barre sur la gauche permet de commencer sur une vue globale, ensuite le plan du site, les story-boards, la page et pour finir le détail de la page.

Je ne peux que conseiller son utilisation, ensuite on n'aime ou pas. Je ne pense pas que cela soit mitigé.

Le site de Denim

La deuxième application est Pencil Project, Pencil est une extension qui transforme Firefox en une application de dessin permettant de réaliser des IHM, schémas canevas, etc. L'application peut-être aussi utilisée en standalone indépendamment de Firefox.

Vous disposez pour cela de différentes formes et widgets que vous pourrez modifier à votre convenance. Parmi ces formes, on retrouve le plus part des contrôles Windows. L’application propose également un éditeur wysiwyg ainsi que les fonctions nécessaires au positionnement et à la manipulation des éléments.

Chaque document peut contenir plusieurs feuilles de dessin apparaissant sous forme d’onglet. L’un des intérêts de Pencil est de vous permettre de superposer ces différentes feuilles.

Pencil permet d’enregistrer votre travail au format *.epz (a single XML-based file) ou de l’exporter au format *.png

Pencil est réellement très simple à manipuler et permet de créer, très facilement, un canevas de site web ou d’application. On pourra évidemment utiliser bien d’autres applications pour obtenir ce résultat, mais avec un poids de moins de 400 Ko et tout cela en Open Source, rien d'équivalent !

Une fois de plus je ne peux que conseiller son utilisation, il permet de faire des maquettes Web avec une très grande rapidité et une très bonne qualité de rendu. Ideal pour présentation client ou des spécifications.

Le site de Pencil Project

Le planning des itérations

SecureOne — Mon, 05 Jan 2009 22:14:00 +0100

Dernier billet d'une série de trois articles sur la panification Agile, nous avons abordé dans un précédent billet le principe de la planification Agile et détaillé dans un deuxième, une méthode de créer son planning de release. Ce dernier billet propose d'expliciter la démarche pour mettre en oeuvre le planning des itérations.

Pour rappel, le planning de relesase est une vue de haut niveau du planning du projet, le planning des itérations est une vue granulaire de ce même projet. Il a pour objectif de dénombrer l'ensemble des taches par cas d'utilisation.

La création du planning des itérations est une démarche plus simple en terme de phase par rapport au planning de release. L'équipe projet va dans un premier temps identifier l'ensemble des tâches par cas d'utilisation, estimer les taches et éventuellement mettre à jour le planning de release.

Identifier les taches des cas d'utilisation

Avant de commencer cette activité, il est important de prendre conscience qu'il n'est pas nécessaire d'identifier l'ensemble des tâches pour l'ensemble des cas d'utilisation lors de cette première planification. Imaginons un projet avec 20 cas d'utilisation, en moyenne un cas d'utilisation regroupe 10 taches, nous devrions identifier plus de 200 taches ! Travail laborieux qui pourrait être remis en doute avec l'avancée du projet. Il est nécessaire de garder en tête les bases des méthodes agiles, dont "juste à temps". Il n'est logique de se lancer dans une activité d'identification de l'ensemble des tâches avant d'avoir commencé le projet. Celui-ci pourrait voir évoluer son périmètre après les premières livraisons ou selon certaines contraintes non identifiées à ses débuts.

À partir de desiderata, nous allons essentiellement travailler sur la première itération et identifier les relations entre la première et la deuxième itération. Chaque cas d'utilisation de la première itération sera étudié pour en extraire les taches nécessaires à la conception, le développement et l'intégration.

À la fin de cette première étape, nous avons identifié les tâches nécessaires pour la première itération et éventuellement une première liste des tâches les plus importantes de la deuxième itération.

Nous obtenons un premier tableau qui peut être représenté de la manière suivante :

Itération	Cas d'utilisation	Taches	Type
1	UC 103 - Demande d'inscription	Spécification de ce cas d'utilisation	Conception
		CRUD des données dans le référentiel	Réalisation
		Création d'un formulaire de demande	Réalisation
		Créer le MCD dans le référentiel de données	Réalisation
		Validation des données du formulaire	Réalisation
		Affichage du formulaire	Réalisation
		Test du cas d'utilisation	Intégration
1	UC 101 - Authentification	Spécification de ce cas d'utilisation	Conception
		Formulaire d'authentification	Réalisation
		Appel référentiel de données	Réalisation
		Vérification des données d'authentification	Réalisation
		Vérification du rôle de l'utilisateur	Réalisation
		Affichage interface selon type de rôle	Réalisation
		Test de ce cas d'utilisation	Intégration

Comme vous avez pu le constater, nous avons choisi d'identifier les taches avec des identifiants complémentaires : conception, réalisation et intégration (CRI). Cela nous permet d'évaluer la charge d'activité par acteur.

Calculer les charges par taches

Nous avons à présent une liste de tâches pour mettre en oeuvre nos cas d'utilisation, la deuxième phase consiste à calculer le cout de chaque tache. Les charges sont calculées en heures à la différence des cas d'utilisation qui sont calculés en ideal days. L'idéal est de réussir à avoir des taches d'une durée d'une journée pour faciliter le suivi et l'affectation des charges. Pour l'équipe un jour = taches.

À la suite de cette deuxième activité, nous mettons à jour notre tableau qui peut être représenté de la manière suivante :

Itération	Cas d'utilisation	Taches	Type	Charges
1	UC 103 - Demande d'inscription	Spécification de ce cas d'utilisation	Conception	2
		CRUD des données dans le référentiel	Réalisation	2
		Création d'un formulaire de demande	Réalisation	1
		Créer le MCD dans le référentiel de données	Réalisation	2
		Validation des données du formulaire	Réalisation	3
		Affichage du formulaire	Réalisation	1
		Test du cas d'utilisation	Intégration	1
1	UC 101 - Authentification	Spécification de ce cas d'utilisation	Conception	1
		Formulaire d'authentification	Réalisation	0,5
		Appel référentiel de données	Réalisation	0,5
		Vérification des données d'authentification	Réalisation	1
		Vérification du rôle de l'utilisateur	Réalisation	0,5
		Affichage interface selon type de rôle	Réalisation	2
		Test de ce cas d'utilisation	Intégration	1

Mise à jour du planning de release

Nous avons terminé notre travail sur le planning des itérations. Il nous faut réaliser un dernier travail qui consiste à vérifier s'il existe des éventuelles différences de charge entre les cas d'utilisation du planning de release et ceux du planning des itérations.

Le planning des itérations implique de rentrer dans le détail lors de la phase d'identification des taches, ce travail peut nous permettre de découvrir des éléments que nous avions oubliés lors de la planification des cas d'utilisation. D'ou l'importance de bien identifier les cas d'utilisation (cf. planning de release) lors de la phase de planification des release.

Créer son planning de release

SecureOne — Sun, 28 Dec 2008 18:57:00 +0100

Suite à mon précédent billet sur la planification en méthode Agile dans lequel j'avais abordé le principe du planning de release et d'itération, je vous propose de continuer sur la planification est de développer le planning de release. Dans un prochain billet, je détaillerais la réalisation du planning d'itérations.

Au point de départ, nous avons un client qui nous a contactés pour développer une application. Ce projet est constitué d'un ensemble de besoins à la fois fonctionnel et technique (backlog).

La première action à réaliser dans le cadre de ce projet est de définir le planning de release. L'objectif est d'avoir une vision globale du projet en terme de planning, d'activité et de coût. Comment réaliser un planning de release ? Le schéma suivant nous donne une première approche, que nous allons détailler par la suite.

Un projet est soumis à plusieurs conditions, qui sont régies par le classique triangle : ressources (coût, budget), calendrier, périmètre (fonctionnalités, caractéristiques). Ce sont ses éléments qui vont nous permettre de constituer notre planning de release. Prenons un simple exemple, un client souhaite X fonctionnalités avec un cout de X euros. Après une première estimation des besoins du client, nous devons lui indiquer que par rapport aux coûts nous ne pourrons pas respecter le périmètre. Nous devons appliquer des priorités sur les fonctionnalités avec notre client pour choisir ce qui peut-être fait avec son budget.

L'exercice est de définir un planning de release selon les conditions inhérentes au triangle du projet. Nous pourrons réaliser un premier planning qui sera adapté et modifié selon les contraintes de ce triangle et ceci en relation avec notre client.

Une fois que nous avons déterminé les conditions spécifiques au projet, passons à la pratique et réalisons notre planning de release :

Remarque : Comme je l'ai déjà indiqué dans mes précédents billets, je n'utilise pas la notion de "vélocité" et de "user story" dans mes projets. Ces deux éléments sont trop vagues pour réaliser un projet en mode forfait, ce qui représente 100% de notre activité de développement.

Les activités à réaliser pour créer notre planning de release sont les suivantes :

Identifier les cas d'utilisation
Sélectionner la longueur d'une itération
Estimer la charge par cas d'utilisation
Appliquer les priorités sur les cas d'utilisation
Sélectionner les cas d'utilisation et les date de release

Identifier les cas d'utilisation

L'identification des différents cas d'utilisation est réalisée à partir d'un cahier des charges fourni par le client, d'une liste de fonctionnalités attendues dans le programme, etc.

La première démarche est de compartimenter en cas d'utilisation ou story (pour les non-techniques) les besoins fonctionnels et un cas d'utilisation transverse pour les éléments technique. Cette activité est réalisée par le product ower et le client. Ce sont les acteurs qui ont la vue fonctionnelle du projet. La partie technique sera abordée lors de la constitution du planning des itérations par l'équipe du projet. Il est important de créer un cas d'utilisation tranverses qui prend en compte les besoins du client, car il peut impacter de manière importante sur le budget et le calendrier de projet.

Pour permettre une évaluation budgétaire réaliste du projet (et surtout éviter de s'en rendre compte au milieu ou à la fin du projet), nous essayons d'obtenir une bonne granularité de nos cas d'utilisation. C'est à dire une cinématique nominale pour chaque d'utilisation. Ce qui pourra se traduire sous la forme suivante :

Contexte : Un utilisateur souhaite se connecter à l'application. Cet utilisateur possède un compte dans le référentiel de données.

Acteurs :

Collaborateur : utilisateur référencé dans le référentiel de données
Administrateur : Collaborateur ayant des droits d'administration.

Description du use case : Ce mode d'authentification permet à un collaborateur de se connecter à l'application. Celui-ci accède à une page d'authentification où il saisit son couple identifiant/mot de passe. Le système vérifie les paramètres d'authentification auprès du référentiel de données.

Pré-requis : L'utilisateur est enregistré dans lle référentiel de données.

Descriptif du cas d'utilisation

Le collaborateur ouvre son navigateur et accède à l'application
Le système demande son couple identifiant/mot de passe à l'utilisateur
L'utilisateur saisit son couple identifiant/mot de passe et valide
Le système vérifie les informations en relation avec le référentiel de données. En cas d'échec, on retourne à l'étape 2
Dans le cas d'une première authentification, le système initialise et crée un compte utilisateur dans le référentiel de données. L'application redirige l'utilisateur vers la page principale de l'application.

Post-conditions : Un compte utilisateur a été créé (en cas de première authentification) dans le système. L'utilisateur est sur la page principale de l'application et peut commencer à l'utiliser.

A la fin de cette phase, nous avons identifier les différents cas d'utilisation. Nous passer à la phase suivante.

Sélectionner la longueur d'une itération

Comme je l'ai expliqué précédemment dans mon billet sur "le planning en méthode Agile", la longueur d'une itération est subjective, la majorité des projets agile utilise une longueur de 30 jours (quatre semaines). Cette période ne doit pas être considéré comme acquise, car elle peut à la finalité, nous poser des problèmes dans notre projet. Je conseille de prendre le temps de bien choisir sa longueur lors de la conception du planning de release.

Certains éléments du projet doivent nous aider à définir la période d'une itération. Le premier point qui peut nous aider concerne la longueur du projet dans sa globalité, si nous travaillons sur un petit projet avec de nombreux cas d'utilisation ou story, il est plus intéressant de faire des itérations courtes pour que l'équipe en charge de l'intégration puisse les valider rapidement. Inversement, tous les projets n’ont pas la chance d'avoir une équipe d'intégration attitrée, le planning peut aussi dépendre de leur disponibilité. Pour choisir la longueur d'une itération, Je vous propose une petite liste de facteurs qui peuvent vous aider à la définir :

La taille du projet
Le nombre de cas d'utilisation
Les priorités du client en terme de calendrier
La flexibilité au changement
L'implication du client dans cette méthode de projet
La présence d'une équipe d'intégration spécifiquement sur ce projet
La politique de l'entreprise sur le projet
Le taux d'incertitude sur la mise en oeuvre de certaines fonctionnalités

Ce qu'il faut retenir : Il faut choisir une longueur et la conserver tous au long du projet. Cette longueur correspond au rythme du projet et de l'équipe. L'équipe prend son tempo sur ce rythme et le conserve, un changement de longueur engendrerait une coupure dans ce rythme et perturberaient rapidement les équipes et le rendement du projet.

Estimer la charge par cas d'utilisation

Un planning de release est un planning avec une vision très macro à la différence d'un planning des itérations. Néanmoins, il ne faut pas penser que le travail de calcul des charges doit se faire à la légère. Dans mon précédent billet sur le planning poker, je vous avais présenté une méthode pour calculer les charges par cas d'utilisation. L'activité de planification est réalisée de la même manière pour calculer les charges par cas d'utilisation.

Le calcul de charge ne porte pas exclusivement sur le développement, mais aussi sur la partie spécification (conception) et intégration. Dans notre méthode de travail, nous calculons les charges en idéal days et non en vélocité. La vélocité est considérée comme trop floue par nos clients et les équipes.

Chaque cas fonctionnel est présenté à l'équipe projet par le product ower (par celui qui à la vision la plus fonctionnelle du projet), une première planification est réalisée par la méthode du planning poker.

Les charges pourront être réajustées après la réalisation du planning des itérations (identification des taches par cas d'utilisation). À la fin de ce travail, nous obtenons notre tableau des charges par cas d'utilisation :

Cas d'utilisation	Charge
CU 100	13
CU 101	21
CU 102	8
CU 103	8
CU 104	5

Appliquer les priorités sur les cas d'utilisation

Un des points les plus importants du planning de release est d'appliquer une priorité sur chaque cas d'utilisation. En effet, cela permet de sélectionner les cas d'utilisation qui devront être développés en premier. Cette priorité est appliquée par le client et le responsable du projet, néanmoins, il est important de prendre en compte l'avis des développeur qui peuvent apporter une vision différente concernant la chronologie de réalisation des cas d'utilisation, ainsi que le risque afférent à chaque cas d'utilisation. .

À la fin de ce travail, nous obtenons notre tableau des priorités par cas d'utilisation :

Cas d'utilisation	Priorité	Charge
CU 100	1	13
CU 101	3	21
CU 102	2	8
CU 103	5	8
CU 104	4	5

Sélectionner les cas d'utilisation et les date de release

Après toute cette activité que l'on peut quantifier au maximum sur 2 jours (selon la taille du projet et l'expérience des acteurs), nous avons les éléments suivants :

La longueur d'une itération,
Une liste des cas d'utilisation, avec leurs priorités et les charges.

Nous sommes fin prêts pour réaliser notre planning de release. Ce travail est maintenant assez simple, nous allons associer les cas d'utilisation et les itérations. Pour ce faire, nous prenons les cas d'utilisation prioritaires, nous prenons leurs charges, nous les positionnons dans les itérations.

Nous avons sélectionné pour ce projet une longueur d'itération de 30 jours. Nous allons créer le planning suivant :

Itérations	Cas d'utilisation	Priorité	Charge
Itération 1	CU 100	1	13
Itération 2	CU 101	3	21
Itération 1	CU 102	2	8
Itération 2	CU 103	5	8
Itérations 1	CU 104	4	5

Nous avons dans notre exemple 2 itérations, nous pouvons proposer le planning de release suivant :

La première livraison au bout de 30 jours comportant 3 cas d'utilisation
une deuxième livraison au bout de 60 jours avec l'ensemble du projet.

Il faudra prévoir d'autres livraisons après les retours du client à propos de la première livraison et ensuite lors de la deuxième livraison.

Le Planning Agile

SecureOne — Sat, 27 Dec 2008 21:26:00 +0100

En méthode Agile, nous avons 2 plannings, le planning de release et le planning des itérations (ou sprint).

Planning release

Le planning release permet d'avoir une vision de la réalisation du projet dans sa globalité. Nous pouvons comparer un planning de release à une roadmap d'un projet.

L'exercice à réaliser dans un planning de release est d'évaluer grossièrement les fonctions qui seront livrées à une date donnée (date driven) ou choisir une date de livraison brute pour un lot de fonctionnalités (feature driven). Un planning de release est constitué de jalon qui représente le périmètre du projet à un moment donné.

Le but du planning release est d'avoir assez d'informations pour décider si le projet produira assez de ROI (Retour sur investissements) pour au moins le payer (et gagner de l'argent). Il permet de définir les fonctions que nous devrons développer en priorités (on n'oublie pas la règle des 80/20). Il indique au client, à l'équipe, à la communauté les différentes dates de livraisons.

C'est durant l'étape de définition, du planning release que l'on choisira la durée d'une itération. On parle souvent de sprint de 30 jours en Scrum, ce choix est assez arbitraire et ne se justifie pas, si ce n'est pour indiquer que cela doit être un maximum. Le choix de la longueur d'une itération doit être sélectionnée par rapport au planning de release global et les fonctionnalités du projet. Si le projet est constitué de nombreuses petites fonctionnalités sur un laps de temps court (3 à 4 mois de projet), il est peut-être plus intéressant de faire des itérations de 15 jours pour les faire tester par le client ou les bêta-testeur.

Un planning release est constitué de plusieurs itérations (ou sprint), qui elles-mêmes incluent les fonctionnalités du projet (backlog) au sens fonctionnel.

Planning des itérations

A la différence d'un planning de release qui est une vue de haut niveau du projet, le planning des itérations est une vue à court terme avec plus de détail. Un planning des itérations détail ce qui est nécessaire pour réaliser dans sa globalité une fonctionnalité (un cas d'utilisation).

Un planning d'itérations est constitué de cas d'utilisation (ou story) avec les tâches associées.

Agile Tour 2008

SecureOne — Fri, 26 Sep 2008 17:30:00 +0200

Agile Tour, une série d'événements gratuite répartie sur plusieurs villes européennes pendant tout le mois d'octobre 2008.

L'édition 2008 est organisée sur 7 conférences réparties en France et en Suisse :

   * 01 octobre : Besançon (Le programme)
   * 03 octobre : Mulhouse (Le programme)
   * 06 octobre : Genève (Le programme)
   * 09 octobre : Grenoble (Le programme)
   * 14 octobre : Lille
   * 16 octobre : Toulouse (Le programme)
   * 23 octobre : Valence (Le programme)

C'est le moment idéal pour rencontrer des professionnels de l'agilité, de voir des exemples de mise en place d'Agile en entreprises. Par exemple, Yahoo sera présent à Valence et Grenoble.

La conférence de Grenoble est composée de plus de 12 conférences.

Je ne peux que vous conseiller d'y aller faire un tour, pour ma par je serais le 9 octobre à Grenoble.

Principe 10 - Pas de place pour les Snipers !

SecureOne — Sun, 07 Sep 2008 17:39:00 +0200

Nous voici arrivés à la fin de nos dix principes Agile. Nous finissions sur un des principes que je trouve majeurs pour qui a mis Agile en oeuvre. Celui de la gestion de l’équipe projet.

Le développement Agile repose sur une étroite coopération et collaboration de tous les membres de l’équipe et des intervenants.

C’est une différence et même une divergence par rapport aux méthodes traditionnelles de gestion de projet, ou le chef de projet est celui qui décide et gouverne son projet et souvent de manière unilatérale. Le reste de l’équipe étant essentiellement des exécutants.

Dans un projet Agile, l’ensemble du projet est discuté et partagé avec l’équipe. Le responsable du projet reste néanmoins celui qui prend la décision finale après concertation avec son équipe.

Les principes du développement comprennent le respect des exigences et une documentation légère, et en reconnaissant que le changement est normal et acceptable dans le développement de logiciels.

Cette étroite collaboration rend particulièrement important de clarifier les exigences justes à temps et de garder tous les membres de l’équipe (y compris le produit propriétaire) « sur la même ligne » durant l’ensemble du développement.

Vous ne pouvez certainement pas aller très loin avec des spécifications importantes qui sont réalisées à l’avance et sans une étroite collaboration avec l’équipe. Cas que l’on retrouve trop souvent dans les projets en cascade. Il ne faut pas ensuite s’étonner que le projet ne ressemble pas aux spécifications et encore au réel besoin du client.

Mais contrairement à un projet en méthode traditionnelle, en développement Agile l’équipe travaille vers un objectif commun, créer un meilleur travail d’équipe, favoriser l’esprit d’équipe, et être plus fortes. À la finalité, satisfaire le besoin client.

Si vous travailler avec un responsable qui pense qu’il peut prendre toutes les décisions de manière unilatérale, qu’il possède la science infuse, il est temps de s’en séparer et de changer de méthode de projet !

Dans mes billets suivants, je vous présenterais, comment faire travailler une équipe ensemble avec Scrum

Principe 9 - Les tests c'est pas pour le nuls !

SecureOne — Sat, 30 Aug 2008 15:38:00 +0200

'' En développement agile, le test est intégré dans l'ensemble du cycle de vie, des tests continuent tout au long du développement du logiciel.''

Le développement Agile ne possède pas une phase de test en tant que telle. Les développeurs sont fortement engagés dans les tests et l'écriture des tests unitaires automatiques pour valider leur code.

En complément d'être orienté vers une meilleure qualité des logiciels, c'est aussi important de mettre en œuvre le principe « Des petits développements, itératifs et des livraisons incrémentales ». Avec des tests unitaires automatisés, les tests peuvent être effectués dans le cadre de la compilation, en veillant à ce que tous les éléments fonctionnent correctement chaque fois que la compilation est produite. Cette compilation doit être réalisée régulièrement, au moins une fois par jour, pour que l'intégration soit réalisée au fur et à mesure.

Le but de ces principes est de maintenir le logiciel dans état dit :« livrable » tout au long du développement, afin qu'il puisse être expédié chaque fois que c'est approprié. Il s’avère aussi utile pour ne pas laisser le logiciel accumuler les anomalies et attendre le dernier moment pour les corriger (méthode traditionnelle de développement)

Le XP (Extreme Programming) cette méthodologie Agile va encore plus loin. XP recommande le développement piloté par les tests, l'écriture des tests avant d'écrire le logiciel.

Mais les tests ne doivent pas seulement être réalisés par les développeurs tout au long du développement. Il y a un rôle très important dans l’équipe : l’intégrateur. Comme nous le savons, tous "les développeurs ne peuvent pas tester le caramel !"

Le rôle d'un intégrateur peut changer considérablement en développement agile, dans un rôle plus proche de l'assurance de la qualité que de simples tests. Il y a des avantages considérables d’avoir un intégrateur impliqué dès le début.

Cette situation est amplifiée encore par « Des besoins macro, léger et visuel » en développement agile, l'accent est mis sur la conversation et la collaboration des exigences par rapport à une approche traditionnelle d’écriture lourde des spécifications et des documentations.

Bien que les exigences peuvent être précisées en détail dans le développement agile (tant qu'ils se font juste à temps et pas tout à l'avance), il est tout à fait possible que cela puisse se traduire par une certaine ambigüité et /ou dans certains cas, les membres de l'équipe n’ont pas la même compréhension des exigences.

Alors qu'est-ce que cela signifie pour un intégrateur agile ? Une préoccupation commune des intégrateurs en particulier pour ceux qui changent régulièrement d’environnement projet - est qu'ils ne savent pas précisément ce qu'ils doivent faire comme test. Ils n’ont pas une spécification détaillée pour effectuer le test, alors comment peuvent-ils tester?

Même dans un environnement plus traditionnel de développement, j'ai toujours fait valoir que les testeurs ont besoin de spécification, et pourtant le produit pourrait encore être de mauvaise qualité, peut-être parce que les exigences ont été mal spécifiées ou parce qu'elle a été clairement mal écrite. Une spécification n'est pas nécessairement le bon produit !

En développement agile, il y a une conviction que, parfois - peut-être même souvent - ces choses ne sont réellement évidentes que quand on peut voir le logiciel fonctionner en livrant des petites livraisons incrémentales et progressives et en mesurant le progrès sur un logiciel fonctionnel, le test décisif est de voir le logiciel et alors seulement vous pouvez juger si oui ou non, il est de bonne qualité.

Les tests Agile induisent donc à plus de jugement de la part de l’intégrateur, d’une expertise de ce qui est bon et ce qui ne l'est pas, la capacité d'être plus flexible et avoir la connaissance et la vision de ce que doit être un bon logiciel. Ce n'est pas certainement une simple affaire de suivi de scénario de test, en s'assurant que le logiciel fait ce qui est écrit dans les spécifications.

C’est pour ces raisons, que les tests en Agile nécessitent une très expérience et une expertise !

Principe 8 : La règle du 80/20

SecureOne — Thu, 14 Aug 2008 23:46:00 +0200

La loi de Pareto est plus communément connue sous la règle du 80/20. Cette distribution des probabilités suit une loi des puissances. L’idée qui est régie par cette loi est que la majorité de vos résultats peuvent être réalisés avec un minimum d’effort.

Cette loi est un outil fondamental en gestion de la qualité. Elle est aussi utilisée en réassurance. Cette loi dit que « généralement » 80 % de résultat peuvent provenir de seulement 20% d’efforts !

Par exemple : En fiscalité : 20% des citoyens imposables génèrent 80% de la trésorerie publique, En sport: 20 % de l'effort à l'entraînement permet d'atteindre 80% de la performance, en service après-vente: 80% des réclamations proviennent de 20% des clients.

Cette loi est bien connue des managers : En préparant leurs ambitions, les managers expérimentés savent que seuls quelques éléments majeurs sont décisifs. Le reste sera traité par la même occasion en tant que parties de ces éléments — Juran, 1964

Ainsi, un bon directeur de produits est une personne qui peut voir (à l'avance sans l’avantage du travail déjà accompli) les 20% sur lesquelles se concentrer. En développement Agile, nous devons essayer d'appliquer la règle des 80/20, qui cherche à se concentrer sur l'importance des 20% qui engendre la majorité des résultats.

Si la qualité de votre application n’est pas la première exigence, si vous avez le contrôle sur son périmètre et si la mise à disposition de votre application est votre première priorité, pourquoi ne pas fournir 80 % de votre produit en seulement 20% du temps. En fait, dans ce scénario particulier, vous pourriez vous demander pourquoi faire les derniers 20% restant.

Maintenant, cela ne signifie pas que votre produit doit être fondamentalement bugé, laisser une mauvaise expérience à l'utilisateur, etc. Cela signifie simplement que le développement de certaines fonctionnalités, ou la richesse de certaines caractéristiques, va plus loin et a une diminution de rendement pourrait ne servir à rien.

Cette affirmation n'est elle pas en conflit avec le précédent billet: "terminer" signifie "TERMINER!". Pas réellement, parce qu’à l'intérieur de chaque itération ou Sprint, ce que vous décidez ou ne décidez pas de « de développer » peut ne pas être réalisé à 100%.

Pour exemple, sur la règle des 80/20, Microsoft lui-même a montré que l'utilisateur moyen de Word utilise seulement 8% des fonctionnalités. 8% Et nous pouvons penser que moins de 80% d'entre eux n’utilisent même pas 8%. Si Microsoft n’avait développé que les 8% importante de Word, pourraient ils encore avoir pris la même part de marché? Peut-être, peut-être pas, malheureusement nous ne le saurons jamais.

Il est également utile d'examiner l'impact sur l'expérience de l'utilisateur. Google nous a montré que les utilisateurs préfèrent souvent des applications qui font au plus près du besoin. Seulement ce que vous voulez. Et pas plus. Le reste est sans doute encombrant et en fait, interfère avec l'expérience de l'utilisateur et apporte seulement un intérêt réduit pour un nombre limité d'utilisateurs.

Nous pouvons donc inverser le 80/20, pour dire que seulement 20% des fonctions d’une application seront nécessaires à 80% des utilisateurs. Dans un développement agile, lorsque vous développez un nouveau produit, concentrez-vous sur ce que votre logiciel doit faire avant tous. Pourriez-vous prendre le marché avec toutes les caractéristiques importantes, ou seulement avec des fonctions qui sont moins riches fonctionnellement, en seulement peu de temps ?

En dehors de la réduction des coûts, réduction des risques et des prestations plus élevées en étant plus rapide sur le marché, vous pouvez également vous appuyer sur la première version du produit basé sur le retour du client réel.

Donc, tout cela est réellement du bon sens (cf. MMM notre DGA).

A la finalité, ce n'est pas aussi simple, car il faut être un très bon visionnaire pour découvrir les 20% qui fourniront 80% des résultats. Par expérience et dans de très nombreux cas, les responsables n'ont pas cette vision.

Principe 7 - Terminer une fonction avant de commencer une autre

SecureOne — Thu, 14 Aug 2008 23:22:00 +0200

En développement agile, "terminer" doit réellement signifier "TERMINER!".

Une caractéristique développée dans une itération (Sprint dans Scrum) doit être terminée à 100% à la fin du Sprint.

Trop souvent dans le développement de logiciels, "terminé" ne signifie pas vraiment "TERMINE !". Cela signifie non tester. Cela ne signifie pas forcément que l’aspect graphique est terminé. La plupart du temps, il n'a pas encore été validé par le directeur de produit et encore moins par le client. Cela signifie simplement développer.

Dans une situation idéale, chaque itération ou Sprint devrait conduire à une version du produit. Certes c'est le cas pour la BAU (business as usual) les changements apportés aux produits existants. Dans les projets ou il n'est pas possible de faire une release après chaque Sprint, réaliser chaque caractéristique à la suite, permet d’obtenir une vue très précise des progrès et dans quelle mesure elles correspondent à la cible du projet ou au contraire s’en éloigne.

En développement agile, il faut s’assurer que chaque caractéristique est pleinement développée, testée, l’aspect graphique stabilisé, et accepté par le directeur de produit et le client avant de la considérer comme "TERMINÉE !". S'il y a le moindre doute sur ce qui devrait ou ne devait pas être achevé dans le Sprint pour chaque fonction, "TERMINER!" devrait signifier être livrées.

Une caractéristique peut nécessiter d'autres caractéristiques en voie d'achèvement avant que le produit puisse être réellement expédié. Mais une caractéristique propre peut mériter d’être livrée. Donc, si vous êtes n’est pas sur qu’une caractéristique ce "suffit", posez-vous une simple question: "Est-ce que cette fonctionnalité est prête à être livrée ? ".

Il est également important de bien compléter chaque caractéristique avant de passer à la prochaine ...

Bien sûr, plusieurs caractéristiques peuvent être développées en parallèle dans une équipe. Le travail de chaque développeur est de ne pas passer à une nouvelle fonction jusqu'à ce que la dernière soit livrée. Ceci est important pour s’assurer que l'ensemble des produits est dans un état "prêt à être livré" à la fin du Sprint, et non dans un état où plusieurs caractéristiques sont à 90% ou non testé. Ce qui est une habitude dans les projets de développement traditionnels.

En développement agile, "terminer" signifie "TERMINER!".

La réunion quotidienne - Daily Scrum

SecureOne — Mon, 28 Jul 2008 18:48:00 +0200

La direction est activement impliquée dans Scrum sur une base quotidienne. À la réunion journalière (Daily Scrum), le ScrumMaster écoute attentivement ce que chaque membre de l'équipe annonce avoir réalisé comme activité. Ces informations sont comparées à ce que la direction de projet s'attend à voir réaliser. Par exemple, si quelqu'un a travaillé sur une petite tâche durant trois jours, il est probable que ce membre de l'équipe a besoin d'aide. En outre, la direction fait un point sur l'avancée de l'équipe : ils sont coincés, ils pataugent, sont-ils des progrès ? La direction peut intervenir et résoudre les problèmes si cela est nécessaire.

Le ScrumMaster est également responsable de maintenir l'équipe de projet au plus haut niveau possible de productivité. Lorsque des décisions sont nécessaires dans la réunion quotidienne , prenez-les même si vous avez des informations incomplètes. Il est généralement préférable de procéder avec des informations partielles. Si les informations ne sont pas disponibles, créer un item de backlog (une tâche) pour prendre la décision.

Lorsque des blocages sont signalés au cours des réunions quotidiennes - et l'équipe ne peut pas résoudre elle-même les blocages - le ScrumMaster est responsable de leur résolution ou il escalade le blocage dans les plus brefs délais vers le directeur de produit.

Principe 6 : Concentrez-vous sur la livraison fréquente des fonctionnalités

SecureOne — Mon, 14 Jul 2008 23:58:00 +0200

Le développement Agile c’est la fréquence des livraisons des produits.

Comme nous avons pu le constater dans le principe n°5, les méthodes de gestion de projet traditionnelles réalisent la livraison une fois l’ensemble du produit terminé. On se demande pourquoi ne pas vous vouloir en tirer certains avantages plus tôt? Pourquoi ne voulez pas entendre le retour de l’utilisateur avant de tout construire ? Pourquoi ne pas vouloir regarder ce qui fonctionne et ce qui ne fonctionne pas, avant de tout construire ?

Ce n'est réellement possible qu’en raison de certains des principes importants de développement agile tels que l'approche itérative, des fonctionnalités simples et réalisées justes à temps, la conduite par itération, les tests intégrés dans le cycle de vie, et ainsi de suite.

Garder en vue la livraison, la constance des livraisons des différentes itérations permet de réduire les risques sur les projets et de conserver l’équipe dans une dynamique. On remarque dans tous les nouveaux projets, une « euphorie », une dynamique de groupe au lancement du projet. Cette dynamique s’atténue rapidement plus le projet avance. Agile permet de conserver cette énergie, par cette constance de la livraison.

Ainsi, la fréquence est fréquente ?

Scrum propose des développements par itération (sprint) sur un maximum de 30 jours. À partir de cette période, il doit être possible de réaliser une démonstration de l’itération. Cette démonstration doit permettre de prendre une décision sur cette itération telle que changer certaines fonctionnalités, l’intégrer dans l’architecture globale, la livrer, etc. La réactivité est un important avantage concurrentiel.

Ce qui est assez important, c'est d'en faire une décision positive, de décider ce qui est approprié pour vous. Et puis de s'en tenir, si vous le pouvez conserver un cycle régulier. Un cycle régulier vous permet de planifier, de construire et parce que des travaux de développement agile à un calendrier fixe, la planification est assurée.

Un cycle régulier vous permet également d'apprendre plus efficacement. Votre estimation pourrait être la bonne, elle pourrait être aussi la mauvaise. Si vous estimez des caractéristiques à un niveau granulaire (idéalement moins de 1 jour) et si vous réalisez un suivi dans le temps, vous commencez à connaitre votre taux normal de réalisation. Et quand vous comprenez cela, vous serez surpris de voir à quel point vous réussissez vos prévisions.

Ainsi, en développement agile on se concentre souvent sur la livraison des produits. Et peut-être encore plus important, se concentrer sur des livraisons de produits.

Lean Software Development

SecureOne — Mon, 14 Jul 2008 23:38:00 +0200

J’ai évoqué plusieurs fois la méthode Lean Software Development, j’avais envie de vous la présenter cette technique pour mieux expliquer son but. Mais avant d’aller plus loin, commençons par les origines de la lean Thinging, cela nous permettra de comprendre la cible attendue par cette technique.

Dans les années 40, une petite société nommée Toyota avait l'intention de fabriquer des voitures au Japon. Mais il avait un problème. Puisque les gens n'avaient pas d'argent, les voitures devaient être bon marché. La production de masse était le moyen le moins cher de faire des voitures, mais la production de masse destinée à fabriquer des milliers de voitures du même type, et le marché japonais n'était tout simplement pas compatible, le marché était trop petit pour toutes ses voitures. Donc la question a été, comment Toyota pourrait faire des voitures en petites quantités tout en restant bon marché ?

De ce dilemme, le Toyota Production System a émergé pour former la base d'une toute nouvelle façon de penser la fabrication, la logistique, et finalement le développement produit. Le cerveau derrière cette nouvelle façon de penser était Taiichi Ohno, connu comme le père du Toyota Production System. Au cœur de la réflexion d’Ohno, il y a le principe fondamental de la lean thinging: éliminer les déchets.

Voir les déchets :

Apprendre à voir des déchets est la première étape dans le développement de la Lean Thinking. Si quelque chose n’apporte pas directement une valeur ajoutée telle qu'elle est perçue par le client, il constitue un déchet.

Shigeo Shingo, l'un des cerveaux de la Toyota Production System, a identifié sept types de déchets de fabrication. Sa liste a permis à de nombreux chef de fabrication de trouver les déchets où ils n’auraient jamais pensé à regarder. Pour faciliter le travail des responsables de projet de développement logiciels dans leur quête de trouver les déchets, la Lean Software Development à traduit les sept déchets de l'industrie manufacturière dans sept des déchets du développement qui sont :

Travail partiellement terminé
Processus complémentaire sans valeur ajoutée
Caractéristiques supplémentaires sans valeur pour le produit
Permutation de tâches
Attente (entre deux tâches par exemple)
Le mouvement (Aller quelque part pour rencontrer quelqu'un ou aller chercher quelque chose pour obtenir des informations)
Les défauts, imperfection.

En complément de l’étude des déchets, il existe 6 autres grands domaines :

Amplification de l'apprentissage par rétroaction. La meilleure approche pour améliorer un environnement de développement logiciel est d'amplifier l'apprentissage. L'accumulation de défauts doit être empêchée en réalisant des tests aussitôt que le code est écrit. Le processus d'étude est accéléré par l'utilisation de cycles itératifs courts.

Décider le plus tard possible : L'idée est d'attendre ce que les auteurs de ce terme définissent comme "le dernier moment responsable" pour prendre une décision. C'est le moment où, si l'équipe ne prend pas de décision, la décision sera prise pour eux (ne rien faire est un choix). Les avantages en sont d’éviter ou de retarder les coûts du changement.

Livrer le plus vite possible : C'est la base du développement itératif. Le pourcentage des exigences change des exigences originales de manières non linéairement et ceci plus le temps avance. Typiquement dans les projets de 9-12 mois il y a un changement de 25% (grossièrement) des exigences initiales. Cependant, le cout des exigences augmente par mois de seulement 1 à 2 %.

Responsabiliser l'équipe : la qualité de l’équipe de développement est le facteur le plus important dans la réussite des projets. Afin d'amener les gens à assumer leur responsabilité, qu’ils soient motivés, et se voient comme une équipe, ils doivent être responsables des résultats et autorisés à en faire une réalité.

Construire à l'intégrité - à la fois l'intégrité conceptuelle, et la perception de l'intégrité. Les auteurs font la distinction entre perceptions de l’intégrité et l'intégrité conceptuelle. La perception de l'intégrité est l'expérience du client avec votre logiciel. L'intégrité conceptuelle est de savoir comment bien construire de concert l'architecture et les composants du système pour aboutir à la perception d'intégrité. De toute évidence, les tests unitaires et d'intégration sont une partie importante de l'intégrité.

Avoir une vision d’ensemble : il faut regarder les processus d'abord dans une vue d'ensemble ou de manière holistique, car si vous ne le faites pas, vous pouvez vous retrouver avec des sous-systèmes optimisés ou fragmentés et des solutions qui ne tiennent pas compte de l'ensemble du processus. La résolution habituelle à la résolution des problèmes est de les subdiviser en éléments constitutifs et d'optimiser chaque pièce. C'est suboptimisation, conduite à la «tragédie des biens communs."

Le secret derrière Lean cela réside dans l'élimination des goulets d'étranglement dans les processus de développement sous-jacents et le renforcement de la rétroaction du cycle.

Un rapport menée par McKinsey baptisé ""Applying Lean To Application Development And Maintenance,», explique que cette technique peut conduire à des gains de productivité de 20% et 40%, et que la qualité et la rapidité d'exécution peuvent s"améliorer sensiblement en l'espace de quelques mois. (Boost productivity with lean software development)

Évidemment cette article donne une vu très générale de cette méthode, si vous souhaitez approfondir votre connaissance de ce sujet, je vous recommande fortement l'ouvrage : Lean Software Development: An Agile Toolkit qui est l'ouvrage de référence .

Principe 5 : Des petits développements, itératifs et des livraisons incrémentales

SecureOne — Sun, 06 Jul 2008 19:54:00 +0200

Les projets à base de développement Agile sont livrés en plusieurs petits morceaux, des petites livraisons, des livraisons incrémentales et itératives.

Dans les projets de développement traditionnel, le cycle de vie (simplifié) se compose de l’analyse, le développement et les tests – tout d'abord, toutes les exigences sont recueillies pour l’ensemble du produit, ensuite les éléments du logiciel sont développés, une fois terminé, le produit est entièrement évalué et tester avant sa livraison.

En développement Agile, le cycle de vie et d’analyser, développer, tester, analyser, développer, tester, et ainsi de suite. Réaliser chaque étape pour chaque fonction, une fonction à la fois.

Les avantages de cette approche itérative du développement sont :

Réduction des risques: Permet d’avoir une visibilité de ce qui est achevé à un moment précis du projet.
Augmentation de la valeur : livrer rapidement à des avantages, être en mesure de livrer le produit quand il est considéré comme assez bon, plutôt que de devoir attendre tous les éléments destinés à être livrés,
Plus de souplesse / agilité: on peut choisir de changer de direction ou d'adapter les prochaines itérations sur la base ce qui a été développé et sur l’utilisation du logiciel.
Une meilleure gestion des coûts: si, comme tous les trop nombreux projets de développement de logiciels, vous courez après le budget, une certaine économie peut-être apportée par la méthode Agile.

Pour cette approche et pour être pratique, chaque fonction/caractéristique doit être pleinement développé, dans la mesure où elle est doit être livré, avant de passer à la suite.

Une autre pratique consiste à faire en sorte que chaque fonction/caractéristique soit développée par ordre de priorité, pas nécessairement dans un ordre logique par rapport au logiciel. Plutôt selon des critères de priorités client et de fonctions de haut niveau indispensable au logiciel. Dans le cas contraire, vous pourriez manquer de temp, pour avoir passé du temps sur des fonctions de moindres importances.

Construire les fonctionnalités du logiciel "importante, mais peu technique" est également souhaitable pour la même raison.

Ce n'est que lorsque vous avez terminé tout ce que vous devait avoir comme fonctions, que vous pouvez passer à ce que vous devriez avoir comme fonctions, et ensuite passer à ce que vous pourriez avoir comme fonctions. Sinon, vous pourriez obtenir une situation où vos premières caractéristiques sont fonctionnellement très riches, alors que du côté logiciel les caractéristiques sont de moins en moins sophistiquées avec le temps qui passe.

Essayez de garder votre produit backlog (terme lié à la méthode Scrum) ou votre liste de fonctionnalités pour qu’elle s’exprime en termes de cas d'utilisation, de scénarios utilisateur, ou caractéristiques - pas en tâches techniques.

Idéalement, chaque point de la liste doit toujours être quelque chose qui a une valeur pour l'utilisateur, et toujours vue comme un livrable plutôt qu’une activité pour pouvoir « taper dans les pneus » et de juger de la complétude, la qualité et prêt à livré.

Ce sont les caractéristiques importantes du développement itératif. Ils sont essentiels si vous prévoyez de délivrer dans les délais fixés - un des 10 principes clés du développement Agile.

Principe 4 : Des besoins macro, léger et visuel

SecureOne — Sat, 05 Jul 2008 18:04:00 +0200

La synthèse de cet article : Une équipe de développement identifie les exigences à un niveau élevé et au coup par coup, juste à temps pour chaque élément à développer. Avec une vision globale de l’objectif du projet.

Le développement Agile est idéalement visuel et doit être à la limite de l’acceptable, c'est-à-dire le strict minimum nécessaire pour permettre le développement et l'expérimentation pour procéder avec une efficacité raisonnable. La raison d'être est de minimiser le temps consacré à tout ce qui ne fait pas partie du produit final.

Le développement Agile peut-être confondu à tort par certains comme dépouillé de processus ou de règles. En d'autres termes que l’on réalise les choses au fur et à mesure . Cette approche n'est pas réellement Agile mais plutôt fragile !

Bien que le développement Agile est beaucoup plus souple que les méthodes de développement traditionnelles, le développement Agile n’est pas néanmoins exempt de rigueur et il est basé sur l'approche structurée (Lean Manufacturing) initiée par le groupe Toyota (leader de la productivité) - Remarque: Le travail de Toyota à été permis de créer la méthode "Lean Software Development" qui complète les méthodes Agile pour apporter la qualité tout au long du cycle de vie du projet. Je vous présenterais bientôt un billet sur cette méthode.

Je crois personnellement que les équipes de développement Agile peuvent créer de meilleurs produits s'ils ont une idée assez claire de l'ensemble des besoins avant de partir sur le développement, afin que les décisions de conception qui peuvent s’avérer erronées ne conduisent pas à l'équipe dans des impasses. Elle permet en complément des investissements plus raisonnables pour financer les projets.

Cependant, toutes les exigences identifiées au début doivent être vues à un niveau élevé et dans un format visuel, par exemple, comme un story-board de l'interface utilisateur. À ce stade, les exigences doivent être assez bien comprises pour déterminer les grandes lignes du produit et produire une première prévision du budget et rien de plus.

Idéalement, les équipes de développement Agile identifient les exigences à haut niveau dans des ateliers. Ils travaillent ensemble dans une grande collaboration de manière que tous les membres de l'équipe puissent comprendre les exigences. Il n'est pas nécessairement d’avoir des personnes avec des compétences particulières, comme un architecte comme dans des projets plus traditionnels, afin de recueillir les exigences indépendamment les unes des autres et de les formaliser par écrit. C'est une activité conjointe de l'équipe qui permet à chacun de contribuer et de comprendre ce qui est nécessaire.

XP (eXtreme Programming) applique des « pauses » aux exigences sous la forme de petites parties appelées « User stories ». Ils sont fondamentalement similaires au cas d’utilisation (Use Case), mais sont plus légers et plus simples par leur nature.

Une équipe de développement Agile visualise les exigences sur un tableau blanc et crée des sessions de story-board (séquences de captures d'écran, des visuels, des croquis, des wireframes ou des diagrammes de séquence) pour montrer à peu près à quoi ressembleront la solution et l’interaction de l'utilisateur dans la cinématique de la solution. Il n'existe pas de long cahier d’exigence ou des spécifications à moins qu'il y ait des zones de complexité qui le justifient réellement. Sinon, les story-boards sont tout annotés et seulement lorsque cela est nécessaire.

Une approche commune entre les équipes de développement Agile est de représenter chacune des exigences, cas d'utilisation ou de story board sur une carte et utiliser une T-card (une représentation visuelle très efficace de plusieurs story board) pour permettre aux scénarios d’être facilement déplacés pour permettre d’ajuster les priorités. Exemple de T-card :

Les exigences sont ventilées en très petits morceaux afin de parvenir à ce résultat; en fait, c’est la force des cartes de pouvoir réaliser cette ventilation en très petits morceaux. L'avantage par rapport à une documentation classique, c’est que cette approche est extrêmement visuelle et tactile, vous pouvez être debout autour du système de T-card et le tableau blanc pour discuter de l’avancé, des priorités et des questions.

La technique de la carte et du T-card est très utile quand le contexte métier ou la technologie n’est pas totalement maitrisée par l’équipe projet. Toutefois, quand l’équipe de développement à une expérience importante du métier et peut rapidement identifier le périmètre et les cas d’utilisation, il est préférable d’utiliser un tableau blanc et un appareil photo pour capturer les cas d’utilisation et les diagrammes de séquence. Les cartes restent néanmoins utiles pour se rappeler des différentes exigences nécessaires du projet et pour l’évaluation de la charge.

les besoins évoluent, mais les délais sont fixes. Au cas où il serait nécessaire de changer les priorités ou d'ajouter de nouvelles exigences dans le projet, le responsable du projet doit retirer une charge comparable au montant de la nouvelle exigence avant de pouvoir placer la nouvelle carte dans le projet.

Les équipes traditionnelles de projet qui ne contrôlent pas le changement peuvent terminer le projet hors du champ initial avec le redoutable glissement de planning, une des raisons les plus communes pour quoi les projets de développement échouent.

Les équipes Agile, en revanche, acceptent le changement, en fait, ils s'attendent. Mais elles gèrent le changement en fixant les délais et la négociation.

Les cartes peuvent bien sûr être complémentées par une documentation appropriée (souvent nécessaire pour le client), mais toujours dans un principe de développement agile, il faut toujours documenter le strict minimum d'informations qui permettra à une fonction d'être développées et toujours ventilées en très petites unités.

Pour exemple, pour mes projets nous faisons avec l’équipe de développement des cas d’utilisation (CU), des diagrammes de séquence (DS), les visuels (UHM) un par un sur un tableau blanc, nous terminons une série en prenant des photos du tableau. Ensuite on transfère au client un par un les CU, DS et interface IHM. Une fois stabilisé, nous pouvons écrire le document (par exemple une spécification fonctionnelle), mais jamais avant que le développement du CU ne soit réalisé.

Utiliser Scrum est une bonne pratique pour la gestion des projets, les exigences (ou les fonctionnalités ou les cas d’utilisation, quelle que soit le mot que vous préférez utiliser) sont ventilées en tâches qui ne dépassent jamais plus de 16 heures (c'est-à-dire 2 jours de travail) et de préférence pas plus de 8 heures, de sorte que les progrès peuvent être mesurés objectivement sur une base quotidienne.

Une dernière chose et qui je pense devrait être certainement adopté de PRINCE2 (la méthodologie de gestion de projet pas agile du tout !), est l'idée de s'assurer que tous les besoins sont des éléments à fournir plutôt que des activités ou des tâches. Vous pouvez voir un produit et donner un "coup de pied dans les pneus", afin de juger de sa qualité et de son exhaustivité. Avec une tâche vous ne pouvez pas le faire.

Principe n°3 - Les besoins évoluent, mais les délais sont fixes.

SecureOne — Tue, 24 Jun 2008 06:11:00 +0200

Ceci est un des contrastes frappant avec un projet de développement traditionnel, où un des premiers objectifs est de capturer toutes les exigences connues et leur champ d'application et que toute modification doit être suivie d'une conduite du changement.

Traditionnellement, les utilisateurs sont éduqués qu'il est beaucoup plus coûteux de changer ou d'ajouter des exigences pendant ou après la phase de développement du logiciel. Certaines sociétés citent quelques statistiques impressionnantes destinées à effrayer les utilisateurs. Il devient donc impératif d'inclure tout ce qu'ils peuvent penser - en fait tout ce qu'ils ont toujours rêvé !

Et qui plus est, il est important de le faire lors de la première version du logiciel, parce que nous savons tous que la phase 2 est toujours difficile à obtenir, une fois approuvée 80% des dépenses ont été réalisés de la phase 1.

Ironiquement, les utilisateurs utilisent seulement une infime partie de tout logiciel, plus ou moins 20%. Mais de nombreux projets commencent leur vie avec une portée pléthorique. En partie, parce que personne ne sait réellement qu'elles seront les 20% du produit qui seront réellement utilisés par l'usager. De même, même si les exigences sont soigneusement analysées et traitées en priorité, il est impossible de penser à tout, les choses changent, et les choses sont comprises différemment par des personnes différentes.

Le développement Agile travaille sur un principe complètement différent. Le développement Agile fonctionne sur le principe que les besoins apparaissent et évoluent. Quelques que soient les analyses et conceptions que vous faites, ce sera toujours le cas parce que vous ne pouvez pas vraiment être sûr de vous jusqu'à ce que vous utilisez le logiciel. Et le temps que vous avez passé en phase d'analyse des besoins et de conception, les conditions extérieures ont peut-être changé.

Donc, si vous pensez que personne ne peut réellement imaginer ce que sera la solution finale en début de projet - il est intrinsèquement difficile, voire pratiquement impossible, de construire la bonne solution en utilisant une approche traditionnelle de développement.

Les méthodes de projet traditionnelles combattent le changement, avec des processus de contrôle du changement visant à minimiser et à résister au changement dans la mesure du possible. En revanche, les projets de développement Agile acceptent le changement, en fait, ils l’attendent et l'évaluent. Parce que la seule chose qui est certaine dans une vie, c'est le changement.

Il existe différents mécanismes dans le développement Agile pour gérer cette réalité. Dans les projets de développement Agile, les besoins sont autorisés à évoluer, mais le calendrier est fixe. Donc, pour inclure un nouveau besoin, ou pour modifier une exigence, l'utilisateur ou le directeur de produit doit retirer du projet une charge de travail comparable afin de tenir compte de ce changement.

Ainsi, l'équipe peut continuer à se concentrer sur les délais, et le produit permet d'évoluer dans la bonne direction. Toutefois, il faut aussi présupposer qu'il y a suffisamment de fonctions optionnelles prévues dans le projet pour permettre ces changements, cela doit se faire sans compromettre fondamentalement le produit final.

Mais qu'est ce que l'entreprise pour attendre de ses équipes de développement ? Délivrer le logiciel dans les délais et le budget prévus dans le contrat, et bien sûr avec une qualité acceptable. Tous les professionnels du développement sont bien conscients que vous ne pouvez pas de manière réaliste résoudre tous ces facteurs et espérer répondre aux attentes. Quelque chose doit être variable pour la réussite du projet. En développement Agile, il existe toujours un champ d'application (ou des caractéristiques du produit) qui est variable, le coût et le calendrier ne doivent pas l'être.

Bien que la portée d'un projet de développement Agile est variable, il est reconnu que seule une fraction d'un produit est réellement utilisée par ses utilisateurs et donc une partie des fonctionnalités d'un produit n'est pas vraiment indispensable. Pour pratiquer cette philosophie de travail, il est impératif de commencer le développement par le noyau, et par la suite avec les cas d'utilisation qui ont la priorité la plus élevée, en s'assurant qu'ils sont livrés dans les temps.

Dans cette méthode, nous favorisons le CRI (Conception - réalisation - Intégration) par itérations. Chaque itération terminée, peut-être livrée pour que le client final puisse valider le contenu de l'itération. Cette méthode permet rapidement d’avoir un état des lieux de la charge consommée et celle restant pour satisfaire au besoin.

Principe n°2 - L'équipe Agile doit être responsabilisée

SecureOne — Fri, 20 Jun 2008 23:09:00 +0200

Une équipe de projet de développement Agile doit inclure tous les membres de l'équipe qui doivent prendre des décisions, et les rendre dans les temps.

La participation active des utilisateurs est un des principes clés. L'utilisateur ou le représentant de l'entreprise doit être étroitement associé sur une base quotidienne.

L'équipe de projet doit être habilitée à prendre des décisions afin de s'assurer qu'il est de leur responsabilité de livrer le produit et qu'ils en ont la propriété. Toute interférence avec l'équipe du projet est perturbatrice et réduit leur motivation à livrer.

L'équipe doit travailler ensemble à établir et préciser clairement les exigences, définir les priorités, être d'accord avec les tâches nécessaires pour fournir les besoins, et estimer les charges.

Il peut sembler opportun de se passer d'un niveau de l'équipe au début du projet. Il est tentant d'avoir seulement un sous-ensemble de l'équipe pour commencer (genre le directeur de produit et l'architecte) , car cela est beaucoup plus efficace.

Toutefois, il s'agit d'un principe-clé pour moi ! Faire participer l'ensemble de l'équipe dès le début du projet. Cette méthode assure la participation et l'engagement de toute l'équipe de projet dès le départ, quelque chose qui paie par la suite.

Lorsqu’un défi se pose tout au long du projet, l'équipe se sent un réel sentiment d'appartenance. Si cela peut sembler couteux. Il faut y penser dès la négociation avec le client et lui faire comprendre l'importance.

Un projet c'est avant tous des hommes avant même les méthodes, une équipe soudée est souvent plus importante qu'une méthode de projet, car elle se sent impliquée.