mardi 16 mars 2010

L’intégralité de l’équipe de développements.

L’un des principes à la base de SCRUM, est l’intégralité de l’équipe de développements pour la durée du cycle (l’itération).

Mais, pour plusieurs organisations qui sont habituées d’avoir une mobilité des ressources en cas d’urgence. Cette impossibilité de bouger des individus durant la période du cycle pourrait être problématique. Beaucoup d’organisation ajuste leurs équipes selon les besoins du moment, surtout selon les urgences de l’organisation.

Donc, demander à de telle organisation de respecter l’intégralité de l’équipe durant le cycle de développement. Ce n’est pas une chose facile.

Je travaille comme consultant en informatique depuis plusieurs années, dans différentes organisations du Québec (province de Québec). Et il m’est arrivé de voir ou d’entendre parler des équipes qui évoluaient selon le besoin et les urgences de l’organisation.
« L’expression on sait comme l’équipe est construite, au moment la regarde. La seconde d’après, elle peut changer. »

Ce n’est pas mal en soi, mais toutes décisions organisationnelles à des conséquences positives et négatives. Comme on dit, je ne veux pas faire un procès à ces organisations. Mais, si elles veulent faire le passage à Agile. Ils devront effectuer une bonne réflexion sur les impacts que cela aura sur leur gestion des ressources et des impacts organisationnels.

N’oublions pas que l’engagement est individuel, mais aussi en d’équipe. Donc, si nous brisons cette équipe, l’engagement ne risque de plus tenir. En agile, les individus qui composent l’équipe ne sont pas juste un numéro remplaçable. Mais, une personne importante au sein du projet et que les autres membres compte sur ces efforts pour mener à bien le projet, ou le cycle. Une équipe SCRUM qui s’engage sur la livraison d’une série de taches. Elle fait sur la base de la confiance que chacun à envers les autres.

Donc, lorsqu’on me parle, qu’on me demande de briser cette intégralité. Je demande toujours. Si tu t’engages à livrer quelque chose avec une personne, et le lendemain, je la changerais. Est-ce que cela affecterait ta capacité à livrer, mais surtout la confiance de le faire ?

Je n’ai jamais eu personne qui n’avait pas d’impact sur son travail ou sa vision du projet. Par conséquent, j’accompagne toujours mes clients afin qu’ils comprennent et acceptent les inconvénients et les avantages, avant de lancer dans un premier projet Agile.

Et de notre coté, nous devons prendre aussi conscience que pour certaine organisation, souvent pour les petites, c’est difficile voir impossible de respecter cette intégrité de l’équipe.

En conclusion, il n’a pas de solutions parfaites pour gérer cette intégralité. Il faut juste trouver votre solution à vous. Tout en cherchant, à viser l’intégralité complète de l’équipe de développement.

L’intégralité organique, fonctionnelle, une petite définition.

Suite à la rédaction d’un billet sur la revue de code   et dans laquelle je parlais d’intégralité organique et fonctionne du code. Et j’ai reçu un commentaire judicieux d’une personne qui me demandait d’expliquer ces concepts.

Donc, voici ma vision (une définition qui n’en est pas une) sur ces deux concepts.

Commençons par l’intégralité fonctionnelle. Lorsque nous écrivons du code. Nous ne le faisons pas parce que cela fait joli. Pour démontrer, que nous capable de faire des algorithmes complexes, du code qui ne sert à rien, juste écrire du code.

Une fonction, une classe ou simplement quelques lignes doivent avoir un objectif à remplir. Si j’écris la fonction SupprimerLesEspacesDansUneChaine (la fameuse fonction « TRIM »). Son objectif est de supprimer les espaces dans une chaine et la retourner à la fin, une fois le traitement terminé.

Dans notre exemple, on ne devrait jamais trouver du code pour le calcul de Pi dans cette fonction. Par contre, elle doit contenir le traitement de validations des entrées et une gestion d’erreurs adéquates.

On doit aussi avoir les outils qui démontrent l’atteinte d’objectif. Ce n’est pas juste la parole de son programmeur qui le valide. Souvent, je conseille d’avoir de petits programmes de tests (Unit Test and Fonctionnal Test). Mais, une série d’exemples d’utilisation, lorsque c’est une classe ou fonction d’utilités (la fonction « Trim », ne fait rien de spécifique dans l’application. Mais, elle aide d’autre traitement à atteindre leur objectif à eux.)

Cette intégralité fonctionnelle devrait être couverte par les tests unitaires bien sûr. Mais aussi, par des tests fonctionnels; automatiser si possible. Il est intéressant, de conserver une copie des tests et de leurs résultats aux fins d’archives.

L’intégration organique (ou logiciel),  couvre plusieurs aspects. Bien entendu, le respect de la nomenclature de l’écrire du code (Nom de la classe, des fonctions et méthodes, des variables, etc).

Mais, il faut aussi vérifier que le code produit, ne compile pas juste le poste du développeur qui l’a écrit. Il doit aussi compiler dans les environnements continus ou sur les « Build Machines ».  J’ai déjà vu du code qui compilait sur tous les postes des développeurs. Mais, lorsque nous avions voulu, faire une version officielle avec la Build Machine. Ça avait fait « Boom », le code ne compilait pas du tout.

Pourtant, ce code avait révisé par toute l’équipe. Il respectait les standards de programmations. Mais,  il n’avait jamais été compilé entièrement avec les sources de la version officielle qui était pour la livraison chez les clients.

L’autre aspect souvent oublié, c’est la manière de faire les choses. Beaucoup, d’organisation on des librairies de composantes utilitaires. Et il faut les utiliser, lorsque nous travaillons.

Par exemple, on a beau avoir construit la meilleure fonction de validation d’un NAS (Numéro d’Assurance sociale). Si nous n’avons pas utilisé, la fonction standard de l’organisation. A mes yeux, nous avons un problème d’intégrité organique (ou logiciel).

Il faut chercher à ne jamais réinventer la roue. Il faut l’utilisé au besoin, encore plus en orientés objets avec les principes de la surcharge et de l’héritage.

L’autre aspect, les fameux algorithmes géniaux. Mais, donc le nom du programmeur est marqué en dessous. A moins, que nous lancions une fusée sur Mars.  Je n’aime pas voir, du code que seul le programmeur qui l’a écrit comprend. Que pour toutes corrections ou modifications, nous avons besoin de lui.

Nous devons toujours écrire, du code pour les 10 programmeurs qui vont faire la maintenance de celui-ci. Il existe encore du code qui a été écrit avec des cartes perforées.

La continuité du désigne est aussi une autre chose importante. Les architectes ou les concepteurs des modèles organiques de l’application. Ne sont pas toujours à côté des programmeurs, lorsqu’ils ont besoins d’ajouter une classe ou une fonction dans cet ensemble.

Dans un mode idéal, je sais que c’est la responsabilité du concepteur de prendre cette décision. Mais, nous savons tous qu’en tant programmeur ou analyste qu’il arrive parfois de prendre cette décision sans l’approbation immédiate du concepteur.

Il faut voir l’intégralité comme une gestion des impacts du code produit dans le reste de l’application ou de la solution logiciel.

Et je me répète, encore et encore, les programmes de tests avec leurs résultats sont aussi importants.

Donc, l’intégralité fonctionnelle et organique d’un code est bien plus que le regarde de la qualité d’écriture du code lui-même. C’est une vue d’ensemble dans la validation du code produit.

samedi 13 mars 2010

La revue de code, ce n’est pas l’Inquisition !
L’une des bonnes pratiques des méthodologies Agiles et de l’Extrem Programming, est la révision de code.
Mais, souvent la révision de code est utilisée comme une forme d’Inquisition, une forme de dictature par certains membres de l’équipe.
Les principes qui sont derrière la révision de code ont le but de vérifier le respect des standards de programmations, de la simplicité des algorithmes et ainsi que de la compréhension générale de l’ensemble du code produit par l’équipe.
Elle permet aussi d’augmenter les compétences générales des membres de l’équipe. On peut s’en servir pour aider et former des membres qui ont moins d’expériences.
Mais, malheureusement, dans certaine équipe, certains coéquipiers qui ont un égo trop grand, se serve de cette technique comme une forme d’Inquisition en vers les gens moins expérimentés ou moins forts techniquement qu'eux.
J’ai même vu que certains l’utilisaient pour régler des conflits personnels. Quelle horreur !
La révision de code doit suivre aux minimums ces règles.
  1. Le réviseur doit avoir une compétence égale ou supérieure de celui dont il révise le code. C’est aussi un exercice de formations.
  2. La révision est une recommandation, n’est pas un acte de dieux. Encore moins une condamnation par les pairs. La personne révisée peut, et a le droit de discuter toutes les corrections demandées par le réviseur. Il est même recommandé que cette discussion s’effectue en équipe.
  3. Le réviseur NE DOIT JAMAIS modifier lui-même le code révisé. S’il y a des modifications ou des améliorations à faire sur une partie ou l’intégralité du code, c’est la responsabilité de l’auteur du code. Je répète, le réviseur NE DOIT PAS CORRIGER lui-même le code révisé. Si on veut que l’auteur s’améliore, il doit lui-même faire les corrections.
  4. La révision de code ne doit pas se limité au fichier de code (le support) mais aussi sontintégration, tant organique que fonctionnel dans le reste du projet. L’intégration organique est respect de la culture technique du projet. L’intégration fonctionnelle est le respect de l’objectif de la fonction, de la classe révisée.
  5. On doit aussi inclure dans la révision de la qualité de la documentation. Pas la révision du français ou de l’anglais, oui, la documentation doit être bien écrite. Mais, elle doit aussi aider la compréhension du code qu’elle documente. C’est souvent la partie que les gens oublient. Pourtant, elle est aussi importante que le code lui-même. Car, elle servira à la maintenance de celui-ci.
  6. La recommandation de révision doit toujours être faite par écrit. Premièrement, un texte écrit permet de réduire l’émotivité que les paroles directes ne permettent pas toujours. Et deuxièmement, le texte pourra servir pour le suivi, l’augmentation de la connaissance générale et bien sûr la maintenance du code.
  7. Mais le plus IMPORTANT, toute transmission de révision à une autre personne doit se faire dans le plus GRAND RESPECT. Je dis toujours à mes réviseurs, imaginer que c’est pour vous que vous recevez cette recommandation que vous avez écrite. Donc, comment aimeriez-vous la recevoir ?
En utilisant, cette technique dans un profond respect de tous les membres de l’équipe. Nous allons t’en renforcer la compétence moyenne de l’équipe que de l’esprit d’équipe.
Car, lorsqu’il y a confiance mutuelle au sein de l’équipe, les membres de celle-ci n’ont plus peur de demander de l’aide. Cette demande s’effectue tout naturellement.
De plus, la qualité va aussi augment progressivement. Ce qui va réduire tant le temps de révision que le temps de corrections subséquentes. L’expérience m’a démontré que si on prend le temps de bien le faire et surtout dans le fait dans un profond RESPECT, cette technique est plus que profitable.

jeudi 11 mars 2010

Le “Pair Programming” revu et visité !

L’une des grandes forces de la méthodologie « Extrem Programming (XP) », est bien sont “Pair Programming” ou d’une mauvaise traduction, la programmation en duo.

Pour avoir travaillé en ce monde, je suis conscience tant de sa puissance que de ses forces. Un bon duo pourra rapidement acquérir un rendement de 2.5 à 3 fois, et peut-être plus, leur cumul du travail individuel. Mais, il faut une bonne complémentarité dans l’équipe.

Dans nos grandes organisations avec leurs grands projets, il est facile de trouver les individus qui fonctionneront bien sur ce principe.

Mais, lorsque nous intervenons dans de plus petites organisations, avec les effectifs réduits et aussi le budget d’autant réduit. Il est difficile d’immobiliser, 2 ressources sur une même tâche. Même, si à moyen terme, serait plus efficace.

Prenons par exemple un projet de 700-800 jours/personnes, environ 1 an avec 4-5 ressources. Il est difficile de doubler le nombre de ressources pour faire du « Pair Programming ». Et le temps total du projet (d’autant si c’est la première expérience ensemble des pairs), elle risquerait de ne pas trouver leur vitesse de croisière tant recherchée.

Donc, comment tirer parti de cette force, sans pour autant immobiliser les 2 ressources en même temps. C’est une question que je vais tenter de répondre avec vous.

Faisons ensemble les constats des forces de cette paire, et essayons d’en tirer parti au mieux.

  1. On dit qu’il y a plus dans 2 têtes que dans une.
  2. Qu’en travaillant à 2 sur un même ordinateur, la qualité intrinsèque du code et des algorithmes augmente
  3. Si une personne est absente, surtout lors d’une absence prolongée. L’autre personne peut continuer où l’équipe avait laissé.
  4. L’Augmentation du rendement, augmentation de l’efficacité.

Révisons ensemble cette liste. Essayons d’en exploiter les forces, sans passer à l’absolue du « Pair Programming »

  1. « On dit qu’il y a plus dans 2 têtes que dans une. » Par cette expression, on parle souvent du cumul de connaissance, du cumul d’expérience.
    • Même si les gens ne travaillent pas en pair, il n’est pas interdit de faciliter le travail collectif.
    • Il est recommandé de mettre en place une structure, ou des structures qui permettent l’échange d’information comme les Wikis, les forums à l’interne de votre organisation. Ne paniquez pas, il existe de bonnes solutions opens sources qui pourront vous aider à les mettre en place
    • lorsqu’il y a un problème, qu’une personne ne réussis pas à résoudre toute seule, il n’est pas interdit (même recommander) de demander l’aider. Utiliser momentanément le travail par pair pour résoudre le problème.
    • Après tout, nous n’avons pas besoin du « pair programming » pour travailler en équipe, ensemble !

  1. La qualité du code et des algorithmes.
    • La qualité du code, et des algorithmes est souvent 2 choses qui sont problématiques dans le développement logiciel.
    • Les programmeurs ont souvent le syndrome de « DIEU », en croyant que leur code et leurs algorithmes sont les meilleurs. Mais, c’est FAUX. Le code fait par une personne n’est pas la solution ultime. L’équipe de doit avoir une connaissance générale du travail de tous ces membres !
    • Une autre technique que contient XP (Extrem Programming), c’est la revue de code. Elle permet en groupe ou par un autre membre de l’équipe une revue du code.
    • Une bonne revue de code devrait compter au minimum ces critères.
i. Revue des standards de codification
ii. Le respect de la nomenclature de l’application.
iii. La simplicité de compréhension et la qualité des algorithmes.
iv. La documentation intrinsèque du code et autre documentation nécessaire à sa compréhension.
    • Ce que ce n’est pas une revue de code
i. Un exercice pour démontrer l’incompétence d’un individu
ii. Un procès, une vengeance entre individus.
iii. Une amélioration du code par le réviseur. Le réviseur doit remettre ses recommandations de corrections à l’auteur. Il n’est jamais recommandé d’effectuer soi-même (Réviseur) les corrections à faire
    • Les recommandations de corrections ou d’amélioration ne sont pas actes de Dieux. Elles doivent être considérées comme une « RECOMMANDATION », une « OBSERVATION » et surtout laisser la place à la discuter tant en équipe que dans la relation Révisé-Reviseur.
  1. L’absence ou l’indisponibilité d’une ressource. Le calvaire de tout chargé de projets. Le pair programming nous aide, dans la gestion de cette non-disponibilité d’une ressource. Mais, lorsqu’on ne peut pas avoir 2 personnes qui font le travail, surtout en simultanées. Il est difficile de trouver de la remplacer aux pieds levés.
· Une solution que j’applique dans ces cas là est le principe de la ressource et demi. Une ressource qui a la responsabilité première d’une tache. Généralement, la personne plus expérimentée du groupe.
· A laquelle, s’ajoute une demi-ressource. Généralement, une personne moins expérimentée que la première. Mais, qui a toute la capacité de faire et surtout l’intérêt de le faire.
· Le secret de la sauce, c’est la communication entre les 2. La demi-ressource doit avoir la capacité. Donc, la connaissance nécessaire du «quoi » et du « comment » des travaux.

  1. La fameuse augmentation de la capacité de travail. C’est plus que vrai, qu’il y a de possibilités d’un bon gain de performance. Mais, pour arriver au fameux gain tant attendu, il aura une transition, une adaptation. Car, il ne sera pas immédiat. Les 2 personnes devront apprendre à travailler ensemble. Donc, si on inclut ce délai dans le calcul du gain de productivité. Je ne suis sûr qu’une petite organisation soit capable d’absorber les coûts durant cette transition afin d’atteindre la productivité attendue.

Pour avoir mis en pratique le principe de la ressource et demi, à plusieurs reprises. C’est le meilleur compromis sur plusieurs aspects pour les petites organisations.

Donc, en résumé, le « pair programming » c’est une excellente technique. Je vous la recommande, mais, tout comme application des principes Agiles. Il faut prendre le temps de bien évaluer nos besoins et d’aller chercher les outils dont on a besoin.

Le « pair programming » n’est pas une religion ! Mais, une bonne pratique de développement !