Libellés : , ,

Développeur artisan


We are tired of writing crap.


"Learning. Caring. Practicing. Sharing." The Four Pillars Of Software Craftsmanship

J'ai décidé dans cet article de me faire l'écho d'une mouvance qui refait surface récemment, le "software craftsmanship". Elle a pour but de valoriser le métier du développement logiciel comme l'artisanat au sens puriste du terme : un travail nécessitant savoir-faire, maîtrise et respect.

Après m'être renseigné, j'ai pu constaté que les débats autour de ce thème étaient déjà très avancés puisque l'idée n'est pas nouvelle (initiée au tout début des années 2000 notamment par le livre The Pragmatic Programmer: From Journeyman to Master).

Mon but ici n'est donc pas de lancer un n-ième débat mais plutôt de partager ces valeurs qui à mon sens peuvent apporter beaucoup de choses dans la façon de voir et de fonctionner dans ce métier. Pour illustrer ceci, je ne citerai que Robert Martin et son article sur le sujet qui résume en quelques points ces idées :

What we are not doing:

  • We are not putting code at the center of everything.
  • We are not turning inward and ignoring the business and the customer.
  • We are not inspecting our navels.
  • We are not offering cheap certifications. 
  • We are not forgetting that our job is to delight our customers. 

What we will not do anymore:

  • We will not make messes in order to meet a schedule.
  • We will not accept the stupid old lie about cleaning things up later.  
  • We will not believe the claim that quick means dirty.
  • We will not accept the option to do it wrong.
  • We will not allow anyone to force us to behave unprofessionally. 

What we will do from now on:

  • We will meet our schedules by knowing that the only way to go fast is to go well.
  • We will delight our customers by writing the best code we can.
  • We will honor our employers by creating the best designs we can.
  • We will honor our team by testing everything that can be tested.
  • We will be humble enough to write those tests first.
  • We will practice so that we become better at our craft.  

We will remember what our grandmothers and grandfathers told us:

  • Anything worth doing is worth doing well.
  • Slow and steady wins the race.
  • Measure twice cut once.
  • Practice, Practice, Practice.

Je vous invite donc à lire attentivement les différentes opinions listées dans les sources, elles apportent toutes un point de vue instructif et qui laisse quelques champs de réflexion...

Sources :


Fichier(s) joint(s) :

Publié par Paul-Emmanuel Faidherbe 0 commentaires


Libellés :

Côte de popularité des langages

La société Tiobe, société renommée dans l'audit de code et d'application, vient de publier les nouveaux résultats de son étude des tendances d'utilisation des différents langages de programmation :

Le premier graphique est sûrement des plus intéressants et révélateurs :

Comme on peut le voir, Java est toujours en tête. Certes C est devenu un concurrent important en terme de nombre de développeurs, mais un détail peut cependant faire pencher la balance en termes de "valeur" pour Java. Si on regarde bien ce graphique, on observe une forte chute de l'utilisation de Java durant l'année 2004/2005 : ceci est très probablement dû à la crise économico-financière de l'époque et donc à la baisse du nombre de projets réalisés sur le marché. De là à dire que Java est préférentiellement utilisé au niveau industriel...

Enfin, un dernier point pour évoquer le renouveau du dynamisme de Java amorcé cette année notamment avec la sortie de la version 7, voici un bref résumé du chemin parcouru et des perspectives d'amélioration.

Choisissez votre camp et à vos claviers!


Fichier(s) joint(s) :

Publié par Paul-Emmanuel Faidherbe 0 commentaires


Libellés : ,

SWTBot, tests fonctionnels pour développeurs

A l'heure de l'avènement de Jubula, plateforme de tests fonctionnels pour Eclipse RCP distribué avec Indigo, j'ai décidé de plutôt étudier le fonctionnement de SWTBot et ce pour plusieurs raisons :

  • Le "fonctionnel" ne doit pas être exclusif à la maîtrise d'ouvrage surtout quand il s'agit de test : c'est le reproche principal que je fais à Jubula. Il est à mon sens un peu trop orienté vers cette idée : de prime abord, il ressemble à une grosse usine à gaz prévue pour que les "acteurs du fonctionnel" puisse s'amuser à assembler les pièces du puzzle de leur scénario de test. Utiliser des "bibliothèques" d'actions (clic souris, drag and drop...) ou de comportements de composants (sélection de checkbox...) et les glisser-déposer sur le jeu de test pour créer le scénario me semble un peu moins pertinent qu'une suite d'instructions claires et atomiques écrites noir sur blanc...
  • Faciliter le mariage "intégration continue-tests fonctionnels" parce que chacun d'eux peut s'avérer être une peine en soi, si en plus il faut passer par des manipulations quelque peu capilotractées... Pourquoi faire compliqué quand on peut faire simple, avec juste une suite de tests JUnit!
  • Assurer la maintenance des tests car c'est bien souvent là que sont sollicités les développeurs. Même si certains tests fonctionnels sont parfois livrés dès le départ du projet, joints aux spécifications, dès que celles-ci évoluent (et c'est toujours le cas), ce sont bien les développeurs qui sont chargés des les maintenir. Donc fournir toute une batterie d'outils graphiques pour la réalisation des tests s'avère bien plus lourd et inconfortable que quelques lignes de codes à modifier simultanément à l'application.

Je tiens tout de même à préciser que ces remarques sont entièrement personnelles et subjectives et n'ont en aucun cas pour but de dévaloriser l'outil. Cet article a seulement vocation de mettre en avant certaines facilités offertes par SWTBot du point de vue développeur. Jubula a surement fait le choix d'autres cibles puisque moins particulièrement orienté SWT/Eclipse RCP.

Fonctionnement de SWTBot

Rentrons maintenant dans le vif du sujet. Le principe de base de ce plugin est de fournir un moyen d'exécuter une application basée sur SWT (et plus particulièrement Eclipse RCP), dérouler un scénario d'utilisation et contrôler son comportement. Techniquement, ceci est utilisable très facilement en créant une classe basique JUnit avec un runner fournit : SWTBotJunit4ClassRunner. Pour le reste, l'API parle d'elle-même, exemple : 

@Test
public void testCompilationJava() throws Exception {
	// Préparation de la perspective
	bot.menu("Fenêtre").menu("Afficher la vue").menu("Autre...").click();
	bot.shell("Afficher Vue").activate();
	bot.tree().expandNode("Général").select("Progression");
	bot.button("OK").click();
	bot.menu("Fenêtre").menu("Afficher la vue").menu("Autre...").click();
	bot.shell("Afficher Vue").activate();
	bot.tree().expandNode("Général").select("Marqueurs");
	bot.button("OK").click();
	...
	// Pour supprimer les warnings de la vue 
	SWTBotView markersView = bot.viewByTitle("Marqueurs");
	markersView.show();
	markersView.setFocus();
	markersView.menu("Configurer le contenu...").click();
	bot.shell("Configurer le contenu").activate();
	bot.button("Nouveau").click();
	bot.checkBox("Afficher les gravités :").click();
	bot.checkBox("Avertissement").click();
	bot.checkBox("Info").click();
	bot.button("OK").click();
		
	/*
	 * Normallement, les éléments de la vue sont réduits et on
	 * teste qu'il n'y ait pas la catégorie "Incidents Java".
	 */
	SWTBotTree markersTree = tree(markersView);
	assertEquals(markersTree.visibleRowCount(),0);
}

private SWTBotTree tree(SWTBotView view) {
	List controls = new ChildrenControlFinder(view.getWidget()).findControls(widgetOfType(Tree.class));
	if (controls.isEmpty())
		throw new WidgetNotFoundException("Could not find any tree");
	SWTBotTree tree = new SWTBotTree(controls.get(0));
	return tree;
}

Le but de ce test est de vérifier qu'un projet java a bien été compilé et donc qu'il n'y a pas de marqueurs d'erreur dans la vue "Marqueurs". Simple, directif et concis. Comme vous pouvez le voir, il est possible d'utiliser directement les méthodes "assertXXX" de JUnit pour vérifier le comportement/état des éléments graphiques. La navigation dans l'interface est facilitée par la possibilité d'enchainer les instructions pointées comme lors de la sélection de sous-menus.

SWTBot recèle également quelques fonctionnalités très intéressantes notamment lors d'une utilisation dans un contexte d'intégration continue : système de log avancé et très précis, création de captures d'écran à chaque problème pour connaitre l'état de l'application... Et puisque chaque classe de test relève d'un simple outillage JUnit, une application Eclipse RCP peut être exécutée à partir d'un script ANT en ligne de commande! Que demande le peuple :) Si ce n'est pas encore fait, voici de quoi vous convaincre en moins de 5 min.

Un must-have donc pour tout développeur RCP!

Sources


Fichier(s) joint(s) :

Publié par Paul-Emmanuel Faidherbe 0 commentaires


Libellés : , , ,

Debugger comme un dieu...

Un des pires scénario (et donc des plus récurrents) dans l'apparition d'un bug est sûrement celui-ci :

Le client vient de nous remonter un bug qui semble ne se produire que sur son environnement de production - donc inaccessible et top-secret - et semble-t-il de manière assez aléatoire. Il faut que tu nous corriges ça au plus vite!

Passées les premières sueurs froides, il apparait que sous cet angle, seule une force divine pourrait vous aider à résoudre ce problème : pouvoir débugger l'application sans point d'arrêt (car elle ne peut pas tourner en mode debug sur l'environnement de prod), sans y avoir accès (puisque l'environnement est protégé) et qui plus est pile au moment où intervient le bug...

Rassurez-vous, vous pouvez maintenant invoquer la toute puissance de Chronos Chronon, un plugin Eclipse se définissant comme "time-traveling debugger".

Présentation

Chronon est disponible en version finale depuis le 25 avril dernier (fin de la bêta). Ses principales fonctionnalités sont assez simples mais révolutionnent les usages du debugger classique, comme le résume justement son fondateur Prashant Deva :

* A 'flight data recorder' for Java programs which can record every line of code executed inside a program and save it to a file on the disk. The file can be shared among developers and played back in our special time travelling debugger to instantly find the root cause of an issue. This also means that no bugs ever need to be reproduced!

* A Time Travelling Debugger, with a novel UI that plugs seamlessly into Eclipse, which allows you to playback the recordings. It not only step back and forward but to any point in the execution of your program.

Dans les détails...

La première étape lors de l'utilisation de Chronon est l'enregistrement du déroulement de l'application. Il est possible d'indiquer les packages à surveiller pour que chaque classe mise en jeu soit instrumentalisée en mémoire afin de pouvoir enregistrer tout ce qui s'y passe, ce qui signifie certes une perte de performance (quoique très bien gérée et limitée), mais surtout que seules ces classes-ci sont surveillées (et non les librairies externes éventuellement appelées). Au final, toutes ces informations sont compressées dans un fichier utilisable sur n'importe quelle machine.

La seconde étape, la plus fun intéressante, est la manipulation de ces enregistrements et le debug étape par étape avec la possibilité de remonter le temps. Voici comment se présente l'interface sous Eclipse :

Comme vous pouvez le voir, l'interface parle d'elle-même : beaucoup d'outils très prometteurs! Et tout ceci est très simple d'utilisation. Par exemple, pour trouver la cause de l'erreur levée, il suffit de cliquer sur la ligne en question dans la vue "Thrown exceptions". On peut donc savoir à quel moment du déroulement du scénario elle est apparue et quelles étaient les valeurs de toutes les variables à cet instant précis :

Et il en va de même pour les sorties dans la console : un simple clic sur une ligne renvoie au code exécuté :

Il est donc possible de naviguer en toute tranquillité dans le code qui a été exécuté afin de trouver à quel moment et pourquoi l'application s'est mal comportée. En effet, contrairement à d'autres debuggers "omniscients" focalisés sur l'état des objets, Chronon se concentre sur la notion de temps et permet de retracer le fil de l'histoire. C'est ce qui en fait un concept novateur voire révolutionnaire dans la façon d'envisager la résolution de bugs. Plus de pertes de temps à essayer de le reproduire sur place ou à l'aide de toute une batterie de tests/données créés pour l'occasion. Les équipes peuvent même se transmettre les enregistrements et enquêter indépendamment.

... Et bien plus encore...

Chronon recèle encore bien plus de fonctionnalités toutes plus attirantes les unes que les autres. En vrac :

  • L'enregistrement peut être stoppé/redémarré à tout moment pendant l'exécution de l'application
  • Prévu pour pouvoir supporter des enregistrements sur plusieurs heures, jours...
  • Mise en place d'un serveur d'enregistrement capable de gérer et d'être géré par plusieurs clients
  • Création de logs post-execution (l'explication du fondateur vaut toutes les autres) :
    Since Chronon records the entire execution of your program and we have this very powerful 'query' engine on top of it, we know the exact state of your program at all points in time. We even know exactly which statements were executed and in which order they were executed.

    If you combine those two facts, the order of execution of each statement and the knowledge of program state at all times, you will see that what we are essentially doing can be generalized as a form of a database query. A very complex and custom query but a query nonetheless.
  • ...

Pour conclure, on peut sans hésiter affirmer que Chronon est l'outil à connaître pour enfin avoir la main-mise sur une application et son comportement dans le temps (Marty et Doc' vont pouvoir remiser leur Doloréane!)

Sources


Fichier(s) joint(s) :

Publié par Paul-Emmanuel Faidherbe 5 commentaires


Libellés : ,

Un nouveau magazine pour les hommes...

... et les femmes qui désirent être toujours plus à l'affût des dernières nouveautés de la communauté Java : Oracle Java Magazine.

Tout fraîchement sortit des éditions Oracle, ce bi-mensuel a été créé "par et pour la communauté". Le premier numéro est déjà très prometteur : belle présentation, contenu clair, précis et pertinent. On notera la participation des grands noms des différents projets et de quelques Java Champions.

Un must-have donc à ne pas rater pour être toujours plus aware! Bonne lecture!!


P.S.: Oui un petit titre racoleur de temps en temps ça ne fait pas de mal...


Fichier(s) joint(s) :

Publié par Paul-Emmanuel Faidherbe 0 commentaires
Inscription à : Articles (Atom)