Etant dans la réflexion générale sur l’intégration continue en général, j’ai exploré quelques pistes dans le résumé est ci-dessous. J’espère que ceux qui ne connaissent pas ce processus se rendrons mieux compte de combien il est important dans la vie des nos projets et applications. (j’ai pas mis d’images, désolé :))

Dans le milieu professionnel des entreprises, notre job des développeurs, est d’écrire des applications de meilleure qualité en un minimum de temps. Avec le temps les application deviennent de plus en plus complexes et difficiles à gérer. On nous dit que l’intégration continue (CI) permet d’augmenter la productivité de nos applications en automatisant certaines parties de notre travail. J’ai passé pas mal de temps en cherchant les informations concernant l’intégration continue donc j’ai décidé de partager mes recherches avec vous, afin de vous donner une base de départ pour vos propres exploration si le sujet vous intéresse. Avant de passer plus loin posons nous les questions suivantes :

  • Quels problèmes permet de résoudre l’intégration continue ?
  • Quels sont les outils à mettre en place  et est-ce que ça coûte cher ?
  • Quelles sont les tâches pouvant être automatisée dans notre vie de développeurs ?

Avant de répondre à toutes ces questions nous devons nous poser la question :

Qu’est-ce que c’est l’intégration continue ?

Martin Fowler écrit sur le sujet : http://martinfowler.com/articles/continuousIntegration.html ce que nous pouvons résumer de la manière suivante:

“L’intégration continue est un processus automatisé qui génère, teste, déploie et analyse une application afin de s’assurer qu’elle fonctionne correctement, suit les best practices et s’installe chez le client. Le processus s’exécute avec chaque changement de code source et fourni un retour immédiat aux développeurs.”

Quand on lit cette définition on peut vite avoir peur au premier abord. Ce qu’il faut savoir ce que quand vous mettez l’intégration continue en place dans votre équipe de développement, n’essayez pas de suite de mettre tout en ouvre. Nous y viendrons tout à l’heure lorsqu’on essayera de définir un plan.

Maintenant que nous avons défini ce que c’est une intégration continue, voyons quels problèmes l’intégration continue permet de régler.

Quels problèmes permet de résoudre l’intégration continue ?

Quand vous développez en équipe, il arrive très souvent que votre partie de code marche parfaitement chez vous et lorsque vous intégrez cette pièce de code avec le reste de l’application vous découvre les effets de bord. Surtout si entre temps un autre développeur a mis à jour sa partie de code. De même, combien de fois il arrive que lorsqu’une application est livrée chez le client, des problèmes apparaissent qui ne sont pas reproductibles en local. Tout ces problèmes peuvent “en partie” être gommés en adaptant l’intégration continue.

Le risque

L’intégration continue permet de réduire le risque. Le risque n’est pas bon dans le développement des logiciels. Tout le monde connaît les problèmes de planning, les découvertes de jours manquant presque à la dernière minute. Je dirai que c’est le plus grand risque que nous pouvons avoir, c’est le planning qui bouge constamment. Le processus de CI a un mécanisme de feedback et toute équipe connaît le statut du dernier build ce qui permet entre autres de savoir si le projet est sur les railles. De même, le feedback permet d’identifier les BUGS au plus tôt, ce qui est un autre risque important. Combien moins cher coûte la correction de bug tout de suite grâce au mécanisme de feedback de CI que de le corriger une fois chez le client ? Les impacts peuvent être très importants.

La qualité

Un autre point important est la qualité. Le processus de CI permet de l’augmenter grâce à l’analyse du code et aux test unitaires. Personne n’a jamais testé manuellement tous le chemins possible d’exécution du code dans l’application, tous les if/else etc. les tests unitaires et l’analyse de code automatique permet de le faire pour vous dans le processus de CI.

Maintenant que nous savons comment peut nous aider l’intégration continue, voyons les outils dont se sert l’intégration continue et répondre par la même à la première question.

Quels sont les outils à mettre en place  et est-ce que ça coûte cher ?

Il y a heureusement pour nous plein d’outils qui peuvent nous servir pour mettre en place le processus de CI. Il y a des outils, dont l’administration et la configuration est relativement aisée, qui offrent beaucoup de fonctionnalités et par conséquent sont payant. Nous pouvons citer par exemple Team Foundation Server de Microsoft. Je n’ai pas utilisé exprès le mot “cher” car cette notion est relative et souvent quand le processus de CI est mis en place et rôdé le retour sur l’investissement est perceptible. Il y a aussi des outils OpenSource gratuit qui peut-être ne sont pas si aboutis dans l’administration et la configuration que les versions payantes mais qui cependant permettent également à mettre en place un processus CI robuste. Voyons un peu ce dont on aura besoin (la liste n’est pas exhaustive, vous pouvez trouver d’autres outils en cherchant bien sur le web):

  • Contrôleur de code source (avec le versionning):

- Subversion (http://subversion.tigris.org/) est gratuit et centralisé. Vous aurez également besoin d'un outil comme Tortoise SVN (http://tortoisesvn.tigris.org/) ou AnkhSVN (http://ankhsvn.open.collab.net/) pour travailler avec ce gestionnaire des sources.

- Git (http://git-scm.com/) est gratuit mais décentralisé

- TFS Version Control (avec Team Foundation Server) est payant.

- SourceSafe est payant également.

  • Un outil pour gérer le processus d’intégration continue (vérifie les changements dans contrôleur de sources, déclenche les builds, fourni le feedback à l’équipe de développement).
    • envoie un feedback sur l’état des opérations

 - Visual Studio Team Suite et Team Foundation Server qui est payant.

- CruiseControl.NET (http://cruisecontrol.sourceforge.net/) qui est gratuit.

- TeamCity de JetBrains (http://www.jetbrains.com/teamcity/) qui est gratuit pour les petites équipes et les petits projet.

  • Un outil de build qui compile le code le feedback avec le résultat de la compilation est envoyé par le serveur qui exécute le processus CI.

- MSBuild est gratuit si vous voulez l’utiliser sans le TFS.

- NAnt (http://nant.sourceforge.net/) qui est gratuit également.

  • Un outil pour les tests unitaires.

- MSTest qui se trouve dans Visual Studio (Team Suite et Test, je crois)

- NUnit (http://www.nunit.org/index.php) gratuit et un des plus populaires.

- MbUnit (http://www.mbunit.com/) qui est également gratuit et aussi populaire.

- xUnit.NET (http://www.codeplex.com/xunit) est également gratuit.

  • Un outil pour l’analyse et la métrique du code. Ces outils vous permettent de mesurer divers point comme par exemple le respect des règles de nommage par tous les membres de l’équipe.

- FxCop de Microsoft (http://www.microsoft.com/downloads/details.aspx?familyid=9AEAA970-F281-4FB0-ABA1-D59D7ED09772&displaylang=en).

- StyleCop de Microsoft également (http://code.msdn.microsoft.com/sourceanalysis/Release/ProjectReleases.aspx?ReleaseId=1425) qui est gratuit et qui permet de vérifier le code s’il respecte les best practices.

- NCover (http://www.ncover.com/) qui n’est pas gratuit et qui permet de tester si tous les chemin d’exécution de code ont été testés. L'application doit être en exécution pour cela.

- Gendarme (http://www.mono-project.com/Gendarme) qui a l'air pas mal en analyse statique.

  • Un outil pour exécuter d’autres tests (acceptance, intégration) que les tests unitaires.

- Selenium (http://seleniumhq.org/) pour tester les application web.

- NUnitForms (http://nunitforms.sourceforge.net/) est une extension de NUnit pour tester les WinForms.

- FitNess (http://fitnesse.org/) qui est gratuit et permet d’effectuer les test d’acceptance.

- WatiN (http://watin.sourceforge.net/) qui est également gratuit et qui petmet de tester votre interface web.

  • Un outil pour la création de la documentation à partir des commentaires XML contenus dans le code.

- SandCastle (http://www.codeplex.com/Sandcastle) qui est gratuit.

- NDoc (http://ndoc.sourceforge.net/).

- DOxygen (http://www.stack.nl/~dimitri/doxygen/)

  • Un outil pour le déploiement automatique.

- ClickOnce

- Visual Studio Installer

- WiX (http://wix.sourceforge.net/).

  • D’autres outils qui peuvent servir.

- ReSharper (http://www.jetbrains.com/resharper/index.html) un add-in payant pour Visual studio qui aide au développement et refactoring. Personnellement je ne peux pas m’en passer.

- NDepend (http://www.ndepend.com/) est également payant me permet de gérer et d’analyser le code .NET en spécifiant des règles. Une petite introduction est ici : http://blogs.developpeur.org/tja/archive/2009/10/07/introduction-a-la-d-couverte-de-ndepend.aspx.

Conclusion

Après une petite introduction à l’intégration continue, on devrait y voir plus clair les intérêts de ce processus dans le développement de tous les jours. Vous savez maintenant comment l’aborder et les outils qui peuvent vous servir. Pour ceux qui sont arrivé jusqu’à la fin de cet article (que j’ai remercie car il est un peu long) et qui se rendent compte que je n’ai pas encore traité une question “Quelles sont les tâches pouvant être automatisée dans notre vie de développeurs ?”, je dirai que je vais la traiter dans des prochains posts, comme d’ailleurs d’autres sujets qui sont liés à ça. Si cela vous intéresse vraiment on peut réfléchir sur une mise en place d’une intégration continue à titre d’exemple avec les outils Microsoft ou Open Source. Cela sera également un exercice pour moi, pour progresser dans ce domaine. En tout cas merci pour votre attention :)

A bientôt :)