Archives de catégorie : Développement

image

La détection de doublons de code – Tips #3 Bis

Je vous présentais hier la fonctionnalité de détection des doublons de code proposée par Visual Studio 11, je vous propose aujourd’hui un rapide retour d’expérience sur l’utilisation de cette fonctionnalité sur un vrai projet avec un bon volume de code (620 000 lignes).

image

L’analyse du code a pris 3h30. Le temps d’analyse pour un aussi gros volume de code est certes important mais ne me choque pas plus que cela. Je suis plutôt surpris par le fait que la machine ne soit pas “à genoux” durant l’analyse mais ne soit occupé qu’à  20% au niveau du CPU sachant qu’il ne semble pas y avoir d’autres goulots d’étranglements (mémoire, disque).

Les résultats sont classés en 4 catégories : exact match, strong match, medium match, weak match.

L’analyseur indique que 25% du code semble être du doublon (et peut donc être quasi-supprimé suite à du refactoring) soit dans mon cas plus de 150 000 lignes de code. Je sais que le code est très loin d’être optimisé et qu’il y a beaucoup de redondance de code mais ce résultat est pour le moins plutôt étrange…

J’ai vite été conforté dans mon impression en analysant la qualité des résultats. J’ai commencé l’étude par l’analyse des weak match.

Je n’ai pas réussi à trouver un résultat à peu près pertinent dans les weak match.

Un des exemples typiques concerne ce type de code :

image

Le moteur d’analyse prend en compte uniquement le texte et non pas le vocabulaire en lui-même et trouve donc des clones qui ne sont pas du tout pertinents.

Autre exemple avec l’initialisation “en masse” d’objets, l’affichage de ce type de résultat n’est pas forcément pertinent :

image

image

 

Les bonnes nouvelles se retrouvent plutôt au niveau des correspondances exact ou très voisines :

image

J’ai été ainsi surpris de découvrir qu’un même bloc de code a été repris 58 fois ( ! ) au sein de l’applicatif.

Une séance de refactoring va donc pouvoir être planifié afin d’éliminer cette redondance ainsi que les suivantes.

En résumé, cette nouvelle fonctionnalité est plus proche de l’analyseur de texte que de l’analyseur de code car le vocabulaire n’est pas pris en compte de manière pertinente. Et il ne faut pas se fier au grand nombre de résultats potentiels affiché mais faire un filtre et une analyse de ceux-ci afin de décider des actions à mener pour améliorer la qualité du code.

image

La détection de Copier Coller–Tips #3

Afin de lutter contre les copier coller intempestif et plus généralement d’aider à trouver des blocs de code identiques ou très proches, Visual Studio 11 propose une fonctionnalité de détection de clone de code.

Si l’on prend un exemple simple :

image

Un clic sur le menu Analyze, Analyze Solution for Code Clones permet de lancer une analyse sur le code source de l’intégralité de la solution et d’afficher un nouveau panneau :

image

Il est ensuite possible de naviguer dans les blocs de code détectés afin de refactorer et donc d’améliorer la qualité du code.

A noter que l’outil ne permet pas d’uniquement trouver les blocs de code strictement identique mais permet de faire des analyses légèrement plus poussées. Le nommage des variables n’est par exemple pas pris en compte, si la structure du code est voisine avec des noms de variables différents, la fonctionnalité sera capable de trouver des résultats pertinents.

Point qui peut être intéressant, l’analyse se fait bien sur le code source et non sur l’IL, il n’est donc pas nécessaire que le code compile pour lancer la détection (oui, je sais; c’est tordu mais c’est toujours bon à savoir Sourire).

Inconvénient, l’analyse se faisant sur la structure du code source, l’outil n’est pas capable de détecter du code identique  fonctionnellement mais pas syntaxiquement.

Par exemple le code suivant ne renvoie aucun résultat :

image

A noter que la fonctionnalité ne se concentre que sur des blocs d’une 10 de lignes de code uniquement, les blocs plus petits ne sont pas détectés.

De plus; il est possible de lancer une analyser afin de rechercher des clones d’un bloc de code en particulier. Il suffit pour cela de le sélectionner et de sélectionner le bon élément dans le menu contextuel pour y parvenir.

Et sur du vrai code ? J’ai lancé l’analyse sur l’application sur laquelle je travaille (plusieurs centaines de milliers de lignes de code) et j’attends le résultat depuis 2 heures !

Grosse déception, le moteur d’analyse ne semble à priori pas multithreadé. Sur mon quad-coeur, le process de VS 11 tourne en moyenne à 20%, la consommation mémoire reste à peu près stable, et les accès disque sont faibles. Le CPU semble donc être le goulot d”étranglement…

image

Après 2 heures d’analyse, cela progresse lentement… mais surement… Je mettrais à jour ce post si cela se termine un jour ! Sourire

image

The Siren of Shame

J’aime utiliser des gadgets en entreprise. L’objectif de ceux-ci est d’apporter un côté ludique qui permet de faciliter le travail de l’équipe tout en dédramatisant les choses.

C’est donc avec grand plaisir que j’ai découvert la “Siren Of Shame”.

Ce gadget est en réalité constitué de deux parties :

  • L’élément visible qui est le gyrophare USB qui s’installe en 1 clic de souris
  • Un outil de monitoring qui est capable de se connecter aux principaux serveur d’intégration continue du marché (TFS, Team City, Cruise Control.net, etc.)

L’objectif est simple : alerter de manière visuelle et sonore dès qu’une build est cassé pour la réparer au plus vite.

image

L’installation du logiciel se fait de manière très simple et la configuration est également aisée. En 5 minutes, le système est fonctionnel et nous sommes capables de tester les différents styles de lumière (gyrophare tournant, fondu de lumière, etc.) et de définir jusqu’à quand nous souhaitons avoir les signaux sonores et lumineux (signal pendant un laps de temps défini ou jusqu’à ce que la build soit réparé, etc.).

L’outil propose de plus 3 fonctionnalités intéressantes :

  • Un tableau de bord permettant de voir l’état de toutes les builds
  • Un outil de réputation qui permet d’avoir une liste triée des développeurs selon un ratio nb de buils/nb de builds échouées
  • Un graphique simple d’analyse de l’état d’une build

image

Un outil donc fort simple, qui fait uniquement ce qu’on lui demande sans trop de fioritures.

Avant de vous décrire mon retour d’expérience du système (cela fait un mois que nous l’avons à présent adopté), je vais vous retracer l’historique de la mise en place du serveur de build dans le service afin de bien décrire l’intérêt d’utiliser ce type de gadget et l’effet obtenu.

Pourquoi un serveur de build ?

Une de mes premières actions lors de mon arrivée à Log’in Space il y a maintenant 1 an a été d’analyser l’environnement de développement pour voir comment il était possible de rendre l’équipe plus efficace.

Le service développement fait très fréquemment des releases des différents produits, la création d’une version prenait alors environ 1h lorsqu’il n’y avait de problèmes, et durait beaucoup plus lorsque un problème de compilation non détecté avait lieu.

Les développeurs avaient l’habitude d’effectuer leur checkin après avoir terminé sans forcément faire de getlatest réguliers. Le code présent sur le source control était différent de celui présent sur les postes de développement et de temps en temps il arrivait que le responsable de la release ait une surprise en essayant de compiler le résultat final…

Afin de résoudre ce problème et être beaucoup plus réactif en cas de problème (ie. ne plus être devant le fait accompli mais réagir dès qu’il y a un problème) un serveur de build sous Team Build a été mis en place.

La première étape a été de simplement automatiser la création d’une version, puis de mettre en place de l’intégration continue (plus proche actuellement de la compilation continue). Ainsi chaque développeur est abonné aux alertes proposées par TFS, et est ainsi notifié de la réussite ou de l’échec de la build déclenché par son check-in. De plus l’automatisation a permis de réduire le temps de création d’une version à 15min.

Il s’agit d’un progrès dans le sens où l’on est beaucoup plus réactif mais il me restait à arriver à sensibiliser l’équipe sur le fait de vraiment prêter attention à avoir un code correct et fonctionnel dans le source control, afin d’avoir le plus rarement possible un code invalide.

Et cet objectif a été atteint grâce à la sirène. Les membres de l’équipe souhaitant éviter que la sirène ne s’allume, ils pensent à présent bien aux risques apportés par leur check-in avant de faire leur commit ! La sirène est en effet mise en avant et bien visible de tous, il n’est donc pas nécessaire qu’elle s’allume pour que tout le monde ait conscience de sa présence.

Encore un (tout petit pas) de franchi vers une meilleure qualité logicielle et vers moins de stress pour l’équipe !

Il reste bien évidemment de gros progrès à accomplir  comme l’intégration de l’exécution de tests automatisés par exemple, mais il s’agit d’une évolution qui va dans le bon sens.

Les + et les –

Les +

  • Outil simple à mettre en œuvre, qui fait uniquement ce qu’on lui demande
  • Une API est disponible pour piloter la sirène dans d’autres contextes que l’intégration continue

Les –

  • Lorsque deux builds échouent “en même temps”, les signaux s’arrêtent lorsqu’une des builds a été réparé et non lorsque l’ensemble des builds ont été réparés
  • Très légers bugs dans l’affichage des changesets liés aux builds lors de check-in très rapprochés

Les risques Sourire

J’ai pu identifier deux risques durant ce premier mois d’utilisation.

Le premier concerne les prestataires intervenants sur un de nos projets. L’un deux a eu la bonne idée de casser et de réparer la build entre midi et deux. L’équipe étant en train de déjeuner la sirène a été d’une totale inefficacité ! Il peut être intéressant de garder le système d’alertes afin d’avoir un réel suivi des builds.

Second risque : Si vous mettez Kool & The Gang au bureau afin de mettre un petit d’ambiance, il se peut qu’un membre de votre équipe vous propose d’allumer le gyrophare en cassant une build histoire d’avoir une ambiance son et lumière Smile (oui, oui c’est du vécu…)

image

La revue de code “du pauvre” avec TFS 2010

imageQue cela soit pour les prestataires auxquels nous faisons appels ou pour le code produit en interne par notre service développement, lors de mon arrivée dans ma nouvelle société, j’ai souhaité mettre en place des revues de code afin :

 

 

  • d’avoir une vision précise de la qualité de code produite en interne et en externe
  • être capable d’évaluer les compétences des prestataires auxquels nous faisons appels
  • Déceler les non-conformités le plus rapidement possible afin de mener des actions correctives les moins couteuses possibles
  • faire monter en compétence l’équipe interne en faisant des revues de code en binôme, et en ciblant les formations internes en fonction des lacunes constatées.

Pour cela, j’ai donc cherché comment effectué des revues de code le plus simplement possible avec Visual Studio 2010 et TFS 2010. Visual Studio 2010 ne proposant pas encore de fonctionnalité intégrée comme cela sera pour la V.next, je vous proprose via ce post ma méthode pour parvenir à effectuer ces revues de code, de manière simple et rapide.

Et pour cela, j’utilise la fonctionnalité des alertes de TFS 2010. Il est en effet possible de s’abonner à tout checkin effectué sur un team project directement depuis Visual Studio :

image

Et avec TFS 2010, ces alertes ont gagné de l’intérêt puisqu’elles bénéficient de l’intégration native de Team Web Access :

image

Chaque item présent dans un changeset peut être pointé via un lien, lien renvoyant directement vers le compare avec la précédente version, ce qui permet de simplement voir l’évolution du code entre les deux versions (celle checkinée, et celle avant la modification) :

image

De plus,  les développeurs de TFS ont eu la bonne idée de définir un header reply-to dans les mails des alertes.

Ce qui fait que l’on peut directement répondre à un mail d’alerte, celui-ci arrivera directement dans la boite du développeur qui a effectué le checkin. Ainsi si l’on suit le screenshot du dessus, au lieu de répondre à tfsservice@loginspace.fr qui a envoyé le mail d’alerte, cela sera bien le développeur qui a effectué le checkin qui recevra le mail :

image

Cette technique permet donc d’effectuer des revues de code simplement, en analysant le code modifié grâce aux alertes, et en faisant les remontées aux développeurs directement par mail, ou via des sessions de revues de code en binôme lorsque cela le nécessite.

L’avantage de cette technique réside dans sa simplicité (pas de mise en place d’usine à gaz), et dans le fait que je peux être très réactif (je fais mes revues tous les jours en fin ou début de journée).

L’inconvénient majeur est que le code revu est déjà présent dans le repository. Ce qui nécessite un second checkin pour corriger le code après une revue.

Dans un prochain post, je détaillerais les configurations d’Outlook que j’ai effectué afin d’améliorer encore ce processus de code.

image

L’impact psychologique du nommage

Ceux qui me suivent sur Twitter le savent, je suis en train de mettre en place TFS 2010 au sein de ma nouvelle société et à cet effet nous avons mis en place une toute nouvelle infrastructure matérielle afin d’utiliser un ensemble de machines virtuelles.

Lors de la création de la machine virtuelle destinée à l’installation de TFS 2010, un de mes collègues m’a demandé le nom de machine que je souhaitais pour cette machine virtuelle en me demandant si le nom “VM-TFS” me convenait.

image Je me suis alors empressé de lui dire que je ne souhaitais pas que VM apparaisse dans le nom de la machine afin que les utilisateurs ne puissent pas râler sur l’installation à cause du fait que cela soit une VM. Mon collègue l’a pris sur le ton de l’humour mais j’étais en réalité très sérieux.

Une VM doit réagir comme une machine physique et je ne souhaite pas que les utilisateurs puissent avoir une image négative de TFS à cause du fait qu’il soit installé dans une machine virtuelle. La société n’a pas l’habitude d’utiliser les technologies de virtualisation, il est donc plus simple de ne pas leur mettre sous les yeux un panneau “Attention c’est une VM” à chaque fois qu’ils vont y accéder. L’idée n’est pas de masquer les choses (la nouvelle infrastructure a été présentée après que la migration de TFS 2005 vers TFS 2010 ait été effectué) mais de faciliter l’adoption d’une nouvelle technologie en supprimant des freins liés à des idées préconçues.

Dans le domaine du développement, j’ai également conseillé à plusieurs clients de nommer “intelligemment” certaines classes afin d’inciter une réelle maintenance/refactorisation de celles-ci. Durant des revues de code, ou tests de migration, ou autre type d’intervention, j’ai régulièrement trouvé des classes helpers destinées à faciliter l’utilisation d’une fonctionnalité. Ces classes utilisent souvent un nommage du genre “EasyQqueChose” (EasyDB pour l’accès aux bases de données, EasyXml pour la manipulation XML, etc.) pour bien signifier aux développeurs qu’avec cette classe il sera très simple d’effectuer la tâche qu’ils doivent accomplir.

Seulement avec le temps, la classe destinée à faciliter les choses est devenue un vrai capharnaüm, et est devenue complexe à utiliser. Bien évidemment cette classe doit être refactorée depuis 97879 siècles mais au final elle ne l’est jamais.

Quand je rencontrais ce genre de cas, je proposais souvent la même idée : prendre quelques minutes pour renommer la classe “EasyQqueChose” en “FuckingComplexAndUnusableQqueChose”. Je ne suis parvenu à faire appliquer cette idée qu’une seule fois  (et oui il y a encore beaucoup de développeurs qui ont peur de renommer une classe…) et étrangement quand je suis revenu quelques semaines plus tard chez ce client la classe avait été refactorée (et donc de nouveau renommée).