Tests unitaires et intégration continue

Je vais vous parler de deux notions qui sont assez connexes, et que certaines personnes ont tendance à mélanger un peu.

Les tests unitaires

Le but des tests unitaires est d’automatiser les tests de non-régression. Quand on développe un logiciel, on peut facilement faire des modifications sans se rendre compte qu’elles introduisent des bugs dans certains cas particuliers. C’est ce qu’on appelle des bugs de régression, en ce sens qu’on introduit de nouveaux bugs à la suite d’une évolution fonctionnelle. Comme il n’est pas humainement possible de tester systématiquement tous les cas d’utilisation possible, ces bugs peuvent se retrouver déployés en production, avec tous les problèmes que cela comporte.

Une des notions importantes, quand on fait du développement, est de savoir que plus un bug est détecté tôt, plus il sera facile à corriger. Les gros soucis arrivent quand on fait du « sur-développement » par-dessus un bug de régression ; il devient très difficile de faire un retour en arrière sur le code incriminé, car cela impliquerait de supprimer des fonctionnalités. Il faut alors corriger ce nouveau code, en essayant de trouver une aiguille dans une botte de foin.

Concrètement, les tests unitaires consistent en un ensemble de scripts, qui ont chacun en charge la validation d’un morceau de code (ou d’une classe si vous faite de la programmation orientée objet). Il est assez évident de tester de la sorte les bibliothèques de fonction : les « librairies » peuvent être vues comme des boîtes noires, avec des entrées et des sorties. Il suffit d’injecter certaines données en entrée, et vérifier la conformité de ce qu’on obtient en sortie.
Pour du code applicatif, c’est un peu plus délicat, car on est parfois obligé de mettre en place un environnement de test sophistiqué (bases de données avec lots de test, génération de données aléatoires, gestion des tentatives de hack, …). Mais bien heureusement il existe de très nombreux frameworks pour vous aider à y arriver ; suivant votre plate-forme de développement, vous pouvez vous intéresser à JUnit (Java), SimpleTest (PHP), CppUnit (C++), JSUnit (Javascript), ASUnit (ActionScript), Test::Unit (Ruby), Test::Unit (Perl), unittest (Python), NUnit (.NET), …

Sus aux emails

Il existe plusieurs méthodes de travail qui s’intéressent à la relation que nous avons avec nos boîtes aux lettres électroniques. Pour n’en citer que deux, je dirais GTD et Zero Inbox, dont le but est d’améliorer le traitement des messages que nous recevons, pour être certain de traiter convenablement les informations reçues. Ce sont des approches très intéressantes, dont je vous parlerai dans de futurs posts.

Pour le moment, je vais vous parler de quelque chose d’autre, qui concerne aussi la manière dont nous utilisons les emails en entreprise. Plus particulièrement, je vais vous expliquer pourquoi il ne faudrait jamais – jamais – échanger de documents de travail par email.

Très souvent, les gens ont tendance à s’échanger les documents (spécifications fonctionnelles, spécifications techniques, listes de choses à faire, relevés de bugs, …) par email. Ça commence par un petit document rédigé par quelqu’un sur son traitement de texte ou son tableur. Voulant que ce document soit lu et utilisé par les autres intervenants du projet, cette personne va donc le leur envoyer par email. Les destinataires vont recevoir le document, le lire, et éventuellement le modifier. Les modifications seront elles-mêmes envoyées par email à toutes les personnes impliquées. Jusque-là, c’est assez clair.

Pourtant, malgré cette clarté apparente, le vers est déjà dans la pomme. Plusieurs pièges classiques peuvent apparaître :

  • Plusieurs personnes modifient le même document, puis le renvoient. Vous vous retrouvez avec autant de versions différentes du même document. Tant que personne n’aura fait le travail de « réconciliation » pour fusionner ces versions, vous allez devoir jongler tel un acrobate.
  • Le premier document aura certainement été nommé en respectant une norme, incluant le numéro de version du document et/ou sa date de création. Mais il y a de fortes chances pour que ceux qui l’éditeront ne pensent pas à modifier le nom du fichier avant de le renvoyer.

Le revendicateur

Je vais m’attarder sur un profil très particulier de personnes, celles qui ont le chic pour réclamer et revendiquer toutes sortes de choses, sans arrêt et quelles que soient les circonstances.

Nous avons tous rencontré ce genre de personnes un jour ou l’autre. Alors que vous mettez en place le design logiciel d’une nouvelle application, un de vos développeurs va prendre une heure pour vous expliquer à quel point il est important que tout le monde utilise les mêmes outils de développement que lui, par soucis de cohésion. Ou pendant que vous réfléchissez à une plate-forme serveur, l’architecte logiciel va réclamer à cors et à cris l’utilisation de tel ou tel module, même s’il sait qu’ils n’ont pas été validés pour une utilisation en production. Ou alors, votre supérieur tente de mettre en place une mauvaise méthode de travail parce qu’il n’en connaît pas d’autre. Cela pourrait même être un stagiaire qui revendique le droit d’utiliser une partie de son temps de travail pour travailler sur des projets scolaires.

La première chose à comprendre, c’est que ces personnes ne viennent pas vous casser les pieds pour le plaisir (même si parfois ça y ressemble fortement). Intrinsèquement, les revendicateurs sont des angoissés. Ils n’ont pas trouvé d’autre moyen de diminuer leur anxiété qu’en la partageant avec les autres ; et malheureusement pour vous, ils sont tellement submergés par ces préoccupations qu’ils ne trouvent pas la bonne manière de formuler les choses. Au final, ils tentent d’imposer leurs vues, alors que ce dont ils ont besoin, c’est d’être rassurés quant au fait que leurs problèmes sont connus et pris en compte.

Je distingue quand même deux types de revendicateurs : ceux qui sont de bonne foi, et les égoïstes primaires.

Ce qu’il ne faut pas faire

La réaction naturelle face à un collaborateur qui vous harcèle de la sorte, c’est de l’ignorer. Mais en faisant cela, vous risquez surtout de le voir revenir à la charge, encore plus souvent et de manière encore plus véhémente. Si vous insistez dans cette démarche, vous allez au-devant de gros problèmes : un revendicateur n’accepte pas d’avoir une porte fermée devant lui, il l’enfonce. Certains d’ailleurs finissent par y prendre plaisir et cherchent inconsciemment de nouvelles portes à défoncer.

Livre : Getting Real

Je vous ai déjà parlé de la société 37signals, au travers de ses outils Backpack et Basecamp. Je vais maintenant vous parler du livre qu’elle a publié en 2006 et qui contient toutes les règles de création et de gestion de projets web qu’elle applique en interne : Getting Real, The smarter, faster, easier way to build a successful web application.

Ce livre est disponible :

Le titre du livre est sûrement un gentil jeu de mots avec la très connue méthode Getting Things Done. Ce clin d’œil est une manière à peine déguisée de dire qu’il faut oublier toutes les méthodes existantes, faire table rase et suivre leur direction. Le livre décrit leur propre méthode agile, qui est censée s’appliquer à la réalisation d’applications web, mais peut être utilisée – au moins partiellement – pour d’autres types de projets ou d’organisations.

37signals

37signals a été fondée en 1999, exerçant une activité de web agency. Au cours des années, elle s’est fait connaître en publiant tout d’abord Basecamp, l’outil de gestion de projet utilisé en interne, puis le framework Ruby on Rails sur lequel Basecamp est basé. Depuis, 37signals a sorti plusieurs services en ligne, allant de la gestion de données jusqu’à la relation client, en passant par la messagerie de groupe. Leur blog d’entreprise, Signal vs Noise, qui parle aussi bien des outils édités par la société que de design et de développement web, est très connu et visité.

L’effet tunnel

Toutes les personnes qui ont géré une équipe connaissent l’effet tunnel. C’est lorsqu’il vous est impossible de connaître l’état d’avancement d’une tâche ou d’un projet et que vous n’avez pas d’autre solution que d’attendre que le travail soit terminé pour pouvoir l’évaluer.
Avant d’étudier les origines de ce mal et comment le prévenir, voyons pourquoi l’effet tunnel est très mauvais :

  • Vous n’avez aucune visibilité sur le planning. Comme il est impossible de savoir si la tâche sera terminée demain ou dans 2 semaines, il est tout aussi impossible de prévoir les retards sur l’ensemble du projet. Comment répartir les tâches et affecter les ressources lorsque vous ne maîtrisez pas la réalisation du travail ?
  • Vous ne pouvez pas redresser le tir si le projet part dans une mauvaise direction. Vous pourrez évaluer les dégâts qu’une fois que tout sera terminé. Et bien souvent, vous aurez alors le choix entre vous satisfaire d’une réalisation bancale (travail incomplet, qui ne répond pas aux spécifications, insensé à maintenir) ou tout recommencer à zéro.

L’effet tunnel a toujours pour origine les choix des individus à qui vous confiez les tâches, et la manière dont ils les abordent. Dans tous les cas, vous pouvez l’éviter avec de la diplomatie et de la méthode.

Le glandeur naturel

La plupart du temps, l’effet tunnel est le fait d’une personne à qui vous avez laissé la possibilité de glandouiller tranquillement. Laissez 5 jours à un développeur pour créer un nouveau module, et vous pouvez être certain qu’il va passer 3 jours à faire autre chose, puis 1 journée à se demander ce qu’il va faire et à se motiver pour le faire, puis passer 3 jours à coder comme un fou. Résultat, il sera en retard et aura oublié qu’il devait faire une documentation succincte.

Lorsque vous demandez à un glandeur naturel ce qu’il est en train de faire, il ne va pas vous répondre « Je surfe sur des sites de foot parce que le nouveau championnat commence bientôt », même si c’est ce qu’il a fait pendant les 3 dernières heures. Il va plutôt prendre un air très affairé, peut-être même semblera-t-il agacé que vous lui fassiez perdre son temps, pour vous faire comprendre qu’il est vraiment plongé dans le boulot jusqu’au cou. Vous repartirez avec pour seule information « Je suis en plein dedans, c’est bientôt fini, je te préviendrai quand ce sera bon« , et une indéfinissable impression de vous être fait bananer.

Livre : Managing Humans

Je vais vous parler un peu d’un très bon livre, nommé Managing Humans, écrit par Michael Lopp et publié par Apress en 2007. Depuis 2002, il tient sous le pseudonyme de Rands le blog Rands in repose, dans lequel il parle de ses expériences en tant que manager d’équipes techniques. Et il en a des choses à dire, le bougre, après avoir travaillé pour Symantec et Netscape, entre autres.

Managing Humans - couverture

Le sous-titre du livre est assez explicite : « Biting and humorous tales of a software engineering manager ». Le livre est truffé d’anecdotes amusantes, de mises en situation réelles ou imaginaires, qui en font un ouvrage à part dans l’univers très fourni des livres dédiés à la gestion de projet et au management.
Personnellement, j’ai une affection particulière pour ce livre. Je l’ai acheté à sa sortie en 2007, alors que j’étais en train de créer mon entreprise. Je n’y ai pas trouvé de recette miracle, mais plein d’exemples de choses à faire ou ne pas faire ; je pense avoir évité plusieurs pièges dans la création de mon équipe grâce à ce livre.

Ne pas être un con

Le premier chapitre du livre se nomme « Don’t be a prick ». L’ensemble des 209 pages pourrait être résumé dans cette simple phrase. Ça paraît débile tellement c’est simple. Mais au cours de ma carrière, j’ai franchement rencontré tellement de personnes qui agissaient comme des gros cons, que ça mérite d’être souligné. Que ce soit par bêtise, inexpérience, indélicatesse, fainéantise, vanité ou parce qu’ils n’avaient rien à faire à ce poste, il est sidérant de voir combien de dirigeants sont inaptes à gérer les hommes et les femmes qui composent leurs équipes.

Le carquois du management

Rands utilise une métaphore assez intéressante. Il dit que nos compétences en management sont comme des flèches dans un carquois. Quand on rencontre un problème, on peut prendre la flèche appropriée, prendre un peu de recul, viser et tirer. C’est le titre qu’il a donné à la première partie du livre.

Les méthodes agiles

Cet article fait suite à ceux consacrés au cycle en V et au cycle itératif. Dans l’histoire des méthodes de gestion de projets informatiques, les méthodes agiles sont une évolution relativement récente qui tente de résoudre certains défauts des pratiques qui étaient en usage jusque-là.

Le manifeste agile

La définition de toutes les méthodes agiles est synthétisée par le Manifeste agile, qui a été rédigé en 2001 par plusieurs acteurs de ce domaine. Il distingue 4 valeurs fondamentales et 12 principes.

Les 4 valeurs

(traduction © Wikipedia et al)

  • L’interaction avec les personnes plutôt que les processus et les outils.
  • Un produit opérationnel plutôt qu’une documentation pléthorique.
  • La collaboration avec le client plutôt que la négociation de contrat.
  • La réactivité face au changement plutôt que le suivi d’un plan.
Les 12 principes

(traduction © Wikipedia et al)

  • Notre première priorité est de satisfaire le client en livrant tôt et régulièrement des logiciels utiles.
  • Le changement est accepté, même tardivement dans le développement. Les processus agiles exploitent le changement comme avantage compétitif pour le client.
  • Livrer fréquemment une application fonctionnelle, toutes les deux semaines à deux mois, avec une tendance pour la période la plus courte.
  • Les gens de l’art et les développeurs doivent collaborer quotidiennement au projet.
  • Bâtissez le projet autour de personnes motivées. Donnez leur l’environnement et le soutien dont elles ont besoin, et croyez en leur capacité à faire le travail.
  • La méthode la plus efficace de transmettre l’information est une conversation en face à face.
  • Un logiciel fonctionnel est la meilleure unité de mesure de la progression du projet.
  • Les processus agiles promeuvent un rythme de développement soutenable. Commanditaires, développeurs et utilisateurs devraient pouvoir maintenir le rythme indéfiniment.
  • Une attention continue à l’excellence technique et à la qualité de la conception améliore l’agilité.
  • La simplicité – l’art de maximiser la quantité de travail à ne pas faire – est essentielle.
  • Les meilleures architectures, spécifications et conceptions sont issues d’équipes qui s’auto-organisent.
  • À intervalle régulier, l’équipe réfléchit aux moyens de devenir plus efficace, puis accorde et ajuste son comportement dans ce sens.

Application concrète

Il existe plusieurs méthodes qui suivent l’esprit du manifeste. Elles ont chacune leurs spécificités, mais de manière globale elles œuvrent toutes dans les mêmes voies.

L’affectif

Pour bien gérer les rapports entre les intervenants d’un projet, il est nécessaire de comprendre comment chaque personne fonctionne. Je vais ainsi vous brosser plusieurs portraits types. Évidemment, les collaborateurs avec qui vous devrez travailler ne colleront jamais complètement à ces portraits ; ou plutôt, chaque personne présente des aspects qui peuvent être assimilés à tel ou tel type. À vous de les comprendre et de vous adapter en conséquence.

L’affectif

Si j’ai choisi de commencer par ce profil, c’est parce que nous avons tous une part d’affectif en nous. C’est quelque chose que nous connaissons bien, mais que nous avons parfois du mal à reconnaître ou à accepter chez les autres.

Un « affectif » a tendance à réagir à l’instinct. Quand il a un bon moral, que tout semble se mettre en place favorablement autour de lui, il devient un travailleur efficace et très impliqué. Malheureusement, il suffit d’un petit grain de sable pour stopper la machine.
Un des facteurs les plus importants pour ce genre de personne, c’est la reconnaissance de sa valeur, et donc de son travail. Un affectif pourra se donner à fond, même pendant de longues périodes, tant qu’il sent que ses supérieurs lui en sont reconnaissants et qu’ils apprécient son travail. C’est souvent quelqu’un qui doit être motivé de manière positive continuellement.

À l’inverse, il suffit parfois d’une remarque pour que l’affectif se démotive complètement. Cela peut être juste une question légitime, au sujet d’un bout de code que vous ne comprenez pas ; il aura quand même l’impression que vous pensez qu’il a fait du mauvais boulot. Il existe alors 2 versions, qui aboutissent au même résultat :

  • L’affectif « combatif » décidera que vous avez tort, et travaillera moins ou moins bien par choix. C’est une manière de revendiquer.
  • L’affectif « démoralisé » se mettra à douter de ses capacités et commencera à cogiter, jusqu’à ne plus pouvoir travailler parce que son cerveau est trop occupé.

Approche globale ou pas-à-pas

Il y a plusieurs manières de mener une équipe. Je vais m’intéresser ici à la manière dont on communique pour suivre l’avancement des projets. Cette question est assez intéressante et complexe, car elle a des impacts sur la méthode de gestion de projet.

En fait, les gens peuvent être placés dans 2 grandes catégories :

  • Ceux qui veulent voir leurs projets de manière globale.
  • Ceux qui privilégient les petites avancées.

Je ne parle pas de la manière dont on choisit d’aborder les projets, mais plutôt comment on a tendance à réagir naturellement, comment on se sent mieux de travailler. Il y a des avantages et des inconvénients aux deux. Il est bon de savoir dans quelle mouvance on se situe et comment sont nos collègues, pour améliorer le travail d’équipe.

L’approche globale

Certaines personnes éprouvent le besoin vital de comprendre les projets dans leur globalité pour pouvoir travailler dessus. Ils ont souvent une bonne vision de l’ensemble des forces et des faiblesses d’un programme en cours de conception. Pour eux, le seul moyen raisonnable d’exécuter une tâche est de le faire de la bonne façon (ce qui pour eux signifie souvent d’y réfléchir pendant des mois pour être certain de prendre en compte tous les cas imaginables et inimaginables).

Le problème avec ces personnes, c’est qu’elles peuvent tomber dans l’immobilisme. Elles considèrent souvent qu’une réalisation incomplète ou imparfaite est pire que de ne rien faire. Et les tergiversations peuvent durer longtemps avant de définir la manière dont une tâche peut être effectuée suffisamment bien pour les satisfaire.

Le pas-à-pas

D’autres personnes, au contraire, sont capables de démarrer un projet très rapidement et de le faire avancer par évolutions successives. Ils ont une bonne idée du travail qui peut être réalisé en fonction des ressources disponibles à un instant donné, et connaissent souvent tous les petits détails techniques de leurs projets.

Par contre, ces personnes ont besoin d’être encadrées de près, car elles peuvent faire prendre à leurs projets des directions non souhaitables. Le souci, c’est que chaque petite amélioration peut sembler à la fois sensée et peu coûteuse.

Le cycle itératif

Si vous avez lu mon billet sur le Cycle en V, vous savez pourquoi ce type de méthode de travail n’est pas adapté à la plupart des projets informatiques, qui réclament une plus grande souplesse. En l’appliquant de manière rigide, on finit par obtenir des logiciels mal adaptés (fonctionnalités sans priorités), livrés en retard (chaque étape bloque les suivantes) et souvent buggués (la technique se plie au fonctionnel).
C’est ainsi qu’est née la méthode du cycle itératif (ou incrémental), qui tente de formaliser une approche plus pragmatique et maniable.

Cycle itératif

Définition

Cette méthode se décompose en 6 étapes, dont 4 qui en constituent le « coeur » :

  • L’expression de besoin : Le client explique ce qu’il veut obtenir. On peut faire un parallèle avec l’étape de faisabilité du cycle en V, et dans une moindre mesure avec les spécifications fonctionnelles. L’idée reste que les informations en entrée peuvent être modifiées par la suite du processus.
  • Le coeur du processus itératif :
    • Spécification : C’est la traduction en langage technique des besoins fournis en entrée. C’est la réponse aux questions « qu’est-ce qu’on fait ? » et « comment on va le faire ? ».
    • Développement : Il s’agit de la réalisation concrète de ce qui a été défini.
    • Validation : C’est l’ensemble des tests qui permettent de s’assurer que le développement effectué correspond bien à ce qui était attendu.
    • Évaluation : Cette étape sert à effectuer un retour sur les écueils rencontrés et les fonctionnalités abandonnées pendant les 3 étapes précédentes, et l’utiliser comme informations d’entrée pour un nouveau cycle.
  • Déploiement : Les livrables qui ont été validés sont déployés pour que le client y ait accès.