TFS 2015: Customisation des activités de build (part2)

Auteur original, de notre ancien blog : Laurent Jacques

tfs1

Aujourd’hui nous allons discuter de la customisation des activités de build avec TFS 2015.En effet, alors que dans un prochain billet j’aborderai le tout nouveau système de build vNext ; il me semblait important de souligner une des (nombreuses) possibilités de customisation du mécanisme existant.

Etant donné le nombre d’étapes, j’ai scindé cette présentation en 2 parties : 

  1. la création d’un nouvelle activité (voir TFS 2015: Customisation des activités de build (part1))
  2. l’intégration du workflow dans la définition de la build.
 

PART2 : Intégration du workflow dans la définition de build.

Lire la suite

TFS 2015: Customisation des activités de build (part1)

Auteur original, de notre ancien blog : Laurent Jacques

tfs9

Aujourd’hui nous allons discuter de la customisation des activités de build avec TFS 2015. En effet, alors que dans un prochain billet j’aborderai le tout nouveau système de build vNext ; il me semblait important de souligner une des (nombreuses) possibilités de customisation du mécanisme existant. Etant donné le volume d’étapes je présenterai la customatisation en 2 parties : 

  1. la création d’un nouvelle activité de build,
  2. l’intégration du workflow dans la définition de build.
PART1 : Création d’une nouvelle activité de build.

Lire la suite

Le chemin vers la qualité est-il unique ? (Part 2 : la Production)

le chemin

Nous avons vu précédemment qu’il n’existait pas de méthodologie parfaite (agile ou non). Que nos besoins en tant qu’unité (équipe, société ou individu) allaient dicter les méthodologies que nous voulons ou pouvons suivre.

A présent, que se passe-t-il lorsque nous produisons ? Comment organiser notre travail effectif afin d’atteindre un niveau de qualité le plus élevé possible ?

Là où les méthodologies peuvent parfois s’arrêter, certaines nous donnent des clés pour améliorer notre code en plus de notre façon de travailler. Et comme le nombre de méthodologies, il est aisé de crouler sous le nombre de « bonnes pratiques » et finalement ne pas savoir par quoi commencer. Voire de s’y perdre et de ne rien faire du tout.

Ici aussi, y a-t-il une bonne méthode à appliquer ?

En plus de notre expérience, deux conférences de Paris Web peuvent nous aiguiller dans cette réflexion.

Tout d’abord, « Code de qualité : ce qu’il faut savoir«  par Julien Wajsberg et Anthony Ricaud et « 100 % de revue de code«  par Agnès Haasser.

 

Quels outils sont utilisés, pourquoi et comment sont-ils intégrés ?

La revue de code est le point commun entre ces deux conférences. Et à raison : cette pratique est initialement la plus […] simple à mettre en place (une chaise suffit !).

La manière classique consiste à faire venir un pair à côté de soi et relire ensemble le code produit à la recherche d’erreurs ou d’oublis techniques comme fonctionnels. Ensuite, de partager sur les améliorations possibles.

Son principal inconvénient reste son coût en temps effectif, tout comme les interruptions que le demandeur réalise auprès de ses collègues.

Chez Soft’it, nous avons pris la décision de ne pas nécessairement impliquer le demandeur dans la revue de code. Le temps est provisionné et c’est à chacun de vérifier ce que les autres ont envoyé. Si besoin, le relecteur fera une remarque directement ou validera simplement le code produit.

Du côté d’Agnès Haasser, les « pull requests » de Git se sont avérés être la meilleure réponse aux besoins de son équipe. Le principe est le même : soumettre son code à la validation des pairs de manière asynchrone. Ce qu’ils ont rajouté est une surcouche de sécurité : préserver la branche master de toute erreur éventuelle. De plus, tous les devs peuvent participer et/ou suivre cette relecture de code, réduisant drastiquement le bus factor.

Une autre pratique pouvant remplacer la revue de code est le pair programming. On place ici aussi 2 développeurs face à une même machine. La revue de code a lieu en même temps que le développement.

Seulement, ce type de mise en place est coûteuse en temps si les développements ne sont faits que de cette manière. Notre choix interne a été de ne l’utiliser que dans trois cas très précis : l’arrivée de nouvelles personnes dans l’équipe, la découverte de nouvelles technologies ou langages et enfin le développement de parties complexes et/ou critiques. Dans le premier cas, le nouvel arrivant participe à la production tout en apprenant. Et nous avons un filet de sécurité en cas de soucis. Ce filet existera également dans le deuxième cas, tout en apportant un recul aux développeurs qui s’émuleront mutuellement. Dans le dernier, l’intérêt est assez évident : deux paires d’yeux valent mieux qu’une. Et si la fonctionnalité est trop complexe, revenir sur le code de quelqu’un peut s’avérer compliqué et finalement faire perdre plus de temps que d’en gagner.

Même si de manière générale le pair programming implique qu’un des développeurs s’occupe du code de production et l’autre des tests, on peut coupler tests et vérification.

 

Le testing, justement. S’il est considéré comme obligatoire chez certains (c’est notre cas chez Soft’it), il ne l’est pas nécessairement d’après messieurs Wajsberg et Ricaud. Ou du moins dès le début.

La décision prise chez Mozilla est de ne pas rendre obligatoire les tests à la création d’une classe. Mais une fois que la première brique est posée, il ne doit plus y avoir de développement sans test.

Pourquoi ce choix ? Parce qu’il est parfois compliqué de définir un premier test concluant lorsque l’on commence à développer une nouvelle fonctionnalité.

Travailler en TDD rendrait évidemment cette règle absurde. Mais cette pratique n’est pas si évidente à mettre en place : certaines architectures, utilisant des ORMs par exemple, rendent l’utilisation de doublures de tests trop lourdes pour être réellement efficaces. On se tournera alors vers des tests d’intégration (qui arrivent plus tard dans le cycle de développement) afin de valider les cas d’utilisation.

Alors quand commencer à tester ?

Lorsque votre architecture le permet. Et elle le pourra toujours très tôt. Lorsqu’il est intéressant de tester également (le faire sur les getters et setters n’a pas d’intérêt en soi). Plus les tests commencent tard, plus il est compliqué de commencer (quel sera le premier test ? Dois-je revenir sur ce qui n’a pas encore été testé ?). 

Leur présence offre un filet de sécurité à l’équipe. Techniquement d’abord : en cas de besoin de refactoring ou de reprise de code par un autre développeur. Ils sécurisent la modification : si on casse quelque chose, on le sait très tôt.
Fonctionnellement, écrire des tests correspondant au cheminement d’un user donnera une meilleure confiance dans le produit terminé. Notamment lors de corrections de bugs. Idéalement, un ou plusieurs tests devront valider la correction, scelleront sa correction et serviront de gardiens face aux régressions.

 

Enfin, l’intégration continue. Le nom du produit varie, mais l’intérêt et l’implémentation restent les mêmes : s’assurer qu’à tout moment, on ne livre pas un produit cassé aux clients.
La solution est modulable : vous pouvez limiter son utilisation à une machine de build, les développeurs sont alors assurés que les fichiers disponibles sur le repository ne sont pas à même de les empêcher de travailler. Exécuter les tests automatiques (unitaires et d’intégration), voire utiliser un analyseur de code (FxCop, NDepend, …) afin de sécuriser les règles de développement. 

Si les pratiques se retrouvent souvent dans les organisations, leurs applications diffèrent parfois très fortement. L’intention est la même : sécuriser les développements et les développeurs. Mais comme dans toute équipe, les besoins et contraintes ne sont jamais les mêmes. Et suivant ces contraintes, chacun doit plier plus ou moins chaque principe ou philosophie. Il se peut que vous arriviez dans une équipe et que certaines de leurs pratiques, notions ou terminologies vous semblent étranges, voire contre-productives. Mais gardez en tête qu’ils ont peut-être des contraintes très fortes qui ne leur permettent pas d’appliquer à la lettre les bonnes pratiques.

Comprenez vos besoins et ceux de l’équipe avant d’amener une réponse toute faite. Prenez en compte leurs peurs, limites et attentes et apportez-leur les pratiques qui leur conviennent.
C’est là le fondement même de l’agilité, utilisez des canevas de solutions plutôt que de vous baser sur celles que vous avez pu connaître avant.

Introduction à la gestion des cycles de vie des applications (ALM)

Introduction à la gestion des cycles de vie des applications

(Application Lifecycle Management – ALM)

       ….

Evidemment, dit comme cela, cela peut paraître un peu abrupte voire déconcertant … Cycles de vie des applications  – Application Lifecycle Management. Mais sous ce nom se cache en réalité l’une des meilleures pratiques logicielles dont l’objectif est de fournir un logiciel de haute valeur et de haute qualité, et ce d’une manière très efficace, rapide et fiable

Quelles sont les différentes étapes de l’ALM ? 

D’un point de vue du développeur, il est courant de penser que le cycle de vie d’un logiciel commence et s’arrête lors du checkout et du commit des modifications du code. 

La réalité est tout autre, comme nous le voyons tous les jours, et couvre beaucoup plus. 

Le cycle de vie des applications commence à partir de la création du projet jusqu’à la livraison en production, comprenant plusieurs étapes dont le développement n’est qu’une petite partie parmi, entre autres, les tests, les documentations et la génération d’installateurs. 

L’ensemble de ces opérations permet de livrer un logiciel de haute valeur et de haute qualité pour le client.

Ce schéma montre le pipeline de déploiement idéal. On y retrouve l’ensemble des opérations automatisées à mettre en place lorsqu’on parle d’ALM.
Le processus est entièrement automatisé, capable de fournir un feedback détaillé de son statut et de celui de ses opérations, et de s’interrompre à chaque étape en cas de détection d’anomalies.
Bien loin de ce déroulement idéal, le plus souvent, il est fréquent que la plupart de ces opérations soient manuelles, partielles et sans fournir de réel feedback.
Même si maintenant il est largement admis que le code source doit être hébergé dans un outil de contrôle de version, et que chaque développeur doit faire des check-out et commit réguliers, il est encore très rare de trouver une plateforme d’intégration continue réelle automatisée, qui gère ne serait-ce que la compilation automatique et le déroulement des tests unitaires. 
A la place, il est fréquent qu’il y ait des flux allant dans toutes les directions, sources de risques et de problèmes à venir, comme le montre le schéma ci-dessous  : 

Quel est le problème avec la livraison de logiciels ? 


  1. Les opérations sont nombreuses, souvent manuelles et sur différents environnements techniques mal maitrisés,
    • Le corollaire est que ces opérations dépendent de quelqu’un (responsable déploiement, chef de projet, expert quelconque). La question est donc : que se passe t’il lorsque cette personne est absente
    • extrêmement répétitives, ces tâches sont une plaie sur le long terme,
    • la réalisation d’une documentation souvent lourde est nécessaire,
    • une courbe d’apprentissage lente pour l’ajout de nouveaux membres à l’équipe,
    • des besoins humains supplémentaires sont nécessaires à l’équipe

  2. Le code source et les paramétrages ne sont pas nécessairement stockés dans le même endroit, mais peuvent être générés à partir de partout et par n’importe qui, n’importe quand : qui contrôle quoi ?
  3. Aucune vraie traçabilité,
  4. Des délais de livraison très long : il peut se passer des jours entre la validation et le déploiement,
  5. Des erreurs sont plus enclines à apparaître. 
En bref : lorsqu’il y a des opérations manuelles, il devient vraiment difficile de répéter, de cadencer et de mesurer la livraison. 

Quels sont les objectifs de l’ALM ? 

Comme vous l’aurez compris maintenant : implémenter l’ALM c’est principalement se concentrer sur l’automatisation de la grande majorité (sinon la totalité) des opérations ; afin d’assurer la création de valeur et des livraisons fiables, rapides et cadencées.
L’idée maîtresse est de réduire les temps de cycle.
Plus le temps de cycle est court, plus le client pourra être satisfait (par plus de fonctionnalités ou même par des corrections de bugs). L’objectif est de favoriser les feedbacks rapides.

Comment? 

Etant donné que cet article est seulement une (très) courte introduction, nous ne plongerons pas plus à fond dans les détails ici. 
Nous énumérerons simplement les différents sujets à couvrir. Ceux-ci seront expliqués plus en détails dans de prochains articles :
  1. Configuration et installation d’un outil d’intégration continue (TFS, Hudson, CruiseControl), 
  2. Mettre au cœur de l’outil l’analyse de qualité (règles de gestion, Sonar, FxCop) ainsi que les tests, le tout avec de l’automatisation, 
  3. Mettre sous contrôle de source tous les paramètres ou fichiers de configuration pour tous les hôtes cibles, 
  4. Lister toutes les autres opérations manuelles, les automatiser et les chaîner entre elles,
  5. Modifier le processus de développement pour s’appuyer davantage sur les tests d’acceptation,
  6. Réduire les délais de feedback (testeurs, clients ….). 

Conclusion 

Cet article n’est que le premier d’une série d’articles introduisant les principes de ALM (intégration continue, déploiement continu…etc). Il vise à présenter simplement ce qui est en jeu tout en abordant les grands principes du cycle de vie des applications.
Dans les prochains articles, nous expliquerons plus en détail avec de cas concrets d’utilisation et d’implémentation, les scénarios de mise en place de l’ALM.

Liens utiles

ALM (sur wikipedia) : pour une explication simplifiée.
Intégration Continuela définition par M. Martin Fowler
Déploiement Continu : la définition par M. Martin Fowler