Podcasts pour les développeurs

Si vous êtes passionné par l’informatique et vous êtes prêt de rester « avec l’informatique » en dehors du travail, les podcasts peuvent vous aider à diversifier votre façon de faire la veille technologique. Personnelement, pour moi les podcasts est une meilleure solution pour profiter du temps que je passe en transport en commun.

Je voudrais mentionner dans cet article quelques podcasts informatiques que j’écoute régulièrement.

• http://lescastcodeurs.com/ - un podcast en français sur le monde Java. Les auteurs sont 4 Français très connus dans la communauté Java.
• http://se-radio.net/ - un podcast en anglais sur le génie de logiciel. Je vous le recommande. Très enrichissant. Il y a des interviews avec des personnes remarquables, comme par exemple avec E. Gamma.
• http://www.computer.org/portal/web/computingnow/onarchitecture - architecture de logiciel par le guru d’UML et la programmation orientée objet Grady Booch. (anglais)
• http://radio-t.com/ - pour ceux qui parlent le russe un podcast sur l’IT. Très riche en contenu et avec de l’humour.

Si vous connaissez des autres podcasts intéressants, vous pouvez les rajouter dans les commentaires de cet article.

TeamCity - Intégration continue (IC)

La suite des articles sur l’industrialisation de développement.

Cet article est consacré au serveur d’intégration continue TeamCity. Ca fait déjà presque 2 ans que j’utilise ce serveur. Très stable, facile à mettre en place et facile à utiliser.

Quelques liens utiles:

1. Télécharger TeamCity: ici
2. Documentation et video tour des fonctionnalités : ici
3. Blog de TeamCity : ici

Cet outil est développé par JetBrains, un éditeur de logiciel très connu dans le monde Java pour son IDE Intellij Idea et dans le monde .NET pour son plugin Resharper.

Ecran principal de TeamCity donne une image instantanée des états des différents builds qui sont présents sur le serveur :

Pour utiliser TeamCity (ou n’importe quel autre serveur d’intégration continue) vous aurez besoin de deux choses : le système de contrôle des versions (CVS, SVN, et à partir de la version 5.0 TeamCity supporte Git et Mercurial– les vcs distribués très à la mode en ce moment) et un outil des builds automatiques (Ant, Maven, MsBuild, etc).

Une particularité de l’architecture TeamCity est l’utilisation des agents – machines physiques qui se sont regroupés ensemble pour permettre l’exécution de plusieurs builds en même temps. Cette fonctionnalité est disponible uniquement dans la version payante.

TeamCity supporte 2 plateformes Java et .NET. Cet argument peut être très intéressants car TeamCity permet dans ce cas là de capitaliser les connaissances sur le processus d’intégration continue pour différents projets. Les meilleures pratiques et astuces du monde d’IC de Java peuvent être réutilisées pour .NET et vice versa.

La fonctionnalité très utile pour les chefs de projets et responsables techniques de projets. Les différentes statistiques sur la santé du processus d’intégration(combien des builds « cassés », les tests unitaires qui provoquent plus d’erreurs, nombre des test unitaires, le temps de « fixage » des bugs, etc ). Les stats montrent l’évolution du projet dans différents contextes : les moments critiques (où il y avait plus d’erreur), la réactivité de l’équipe pour corriger les erreurs, etc.

Mac in our life

Chez Mozilla, on programme avec le Mac :

Pour comprendre pourquoi Google c’est génial, regarder dans quelles conditions travaillent ces « pauvres gars » :

Plus de photos de Google à Stockholm, Sweden, ici.

La puissance de VmWare in action sur mon portable MacBook Pro - Mac Leopard Snow, Windows XP et Ubuntu sont ensemble:

Industrialisation de développement de logiciel (.NET)

Dans cet article je voudrais présenter mon expérience dans l’industrialisation de développement de logiciel. Je vais me concentrer sur les aspects purement techniques.

Je pense que l’automatisation est l’une des caractéristiques principales de l’industrialisation. La première chose à automatiser est un processus de build de votre logiciel. Le strict minimum d’un build automatique :

1. Compilation des sources
2. Packaging (création des *.dll, *.exe ou archive Web, par exemple)

Aujourd’hui, les bons projets rajoutent encore quelques étapes supplémentaires pour assurer la qualité :

1. Tout d’abord, la récupération de la version du système de gestion de version (CVS, SVN, Git, etc).
2. 2 étapes décrit précédemment
3. Lancement des tests automatisés (NUnit+DbUnit.NET)
4. Génération de la documentation (Doxygen - générateur avancé de la documentation technique à partir du code source, les langages supportés - C++, C, Java, Objective-C, Python, IDL (Corba and Microsoft flavors), Fortran, VHDL, PHP, C# )
5. Génération des métriques sur le code (FxCop - signale des problèmes (règle de nommage, performance, architecture(design), sécurité, etc) dans le code, NCover - détermine la couverture du code par les tests, NDepend - analyse les dépendances).
6. Déploiement pour l’équipe de QA si nécessaires.
7. Envoie des notifications à l’équipe de développement sur les résultats des builds (mail, SMS, feed RSS, etc).

Dans le monde .NET, nous avons outil MSBuild (équivalent de Ant en Java) qui permet de faire ces builds. L’exemple du script MsBuild pour compiler une classe C#:

MsBuild contient un certain nombre de tâches (target) prédéfinis. Toutes les 7 étapes que j’ai listé peuvent être réalisées facilement avec les targets standards de MsBuild.

Dans le prochain article je décrirai le serveur d’intégration continue TeamCity qui s’intègre dans la politique d’industrialisation des grands projets.