Note de lecture : Eclipse, par Steve Holzner

Note: 4 ; Un livre de commande, ni bon ni mauvais, mais qui date un peu!

Je profite de la période de noël pour vous asséner l’une de mes petites notes de lecture archéologiques ! Celle-ci date d’une bonne douzaine d’années, ne vous plaignez pas j’en ai de bien plus anciennes. Et que diable, il faut bien que je refourgue mes fonds de tiroir !

Il n’y a pas à dire : depuis quelques années, O’Reilly a perdu de sa superbe. Autrefois incontournables sur leurs sujets, nombre des titres de l’éditeur sont là pour occuper le terrain. C’est le cas de ce titre. De toute évidence, ce titre comble un trou dans le catalogue de l’éditeur. Mais voyons de quoi nous parlons.

Le livre est globalement divisé en 2 parties. La première présente l’IDE Java, tandis que la seconde expose le développement d’applications Java classiques, Web et plugins. La première partie est sans surprise, et l’on effectue le « tour du propriétaire » classique : fonctions de l’éditeur, debogage et profiling, réfactoring, gestion de projets avec Ant, gestion de versions avec CVS, etc… Le tout plus qu’abondamment illustrés de copies d’écran dont, si j’étais mauvaise langue, je dirais qu’elles sont là pour faire du volume. Au moins l’approche est didactique et ne requiert pas vraiment d’effort de la part du lecteur. On regrettera que l’auteur ne prenne aucun parti pris sur l’organisation du travail, des workspaces, etc.. Il se contente d’exposer (bien que clairement) les fonctions disponibles. Pas très inventif, tout ça.

La seconde partie expose en grande partie des éléments que l’on trouve ailleurs : développement d’applets ( !) et d’IHM avec Swing, ainsi que le développement d’applications Web « classiques » en JSP/Servlet, mais sans plugins avancés. La seconde moitié de cette seconde partie est plus spécifique à Eclipse avec SWT et les plugins. J’en conclus que cet assemblage un peu large a pour objet de mettre entre les mains du lecteur un ouvrage « tout en un » où l’on trouvera de quoi démarrer sur la plupart des sujets courants en Java.

Lire la suite

Note de lecture : The Java Developer’s Guide to Eclipse, 2nd edition, par Jim D’Anjou, Scott Fairbrother, Dan Kehn, John Kellerman & Pat McCarthy

Note : 6 ; De l’Eclipse au kilo !

Voici un pavé, du vrai, du gros, du 1000 pages ! Ce gros pavé, justement, se veut la bible du développement avec et pour Eclipse. Honnêtement, cet ouvrage semble venir d’un autre temps, celui où l’on payait les livres au kilo ! Celui-ci n’est plus tout neuf, mais il me semble que même à cette époque cette tendance s’estompait. Et plus encore chez Addison Wesley. Le livre compte 34 chapitres et je n’ai franchement pas l’envie de tous les passer en revue. Heureusement, ceux-ci sont regroupés en 6 parties, ce qui rend plus huain le survol du texte.

La première partie couvre près de 200 pages et est consacrée à l’utilisation d’Eclipse. Les 6 chapitres qui la compose noircissent beaucoup de papier pour dire en grande partie ce que l’on sait ou a déjà deviné. Il y a bien quelques informations à grapillé dans les coins, mais c’est majoritairement un gâchis de temps et d’espace.

La seconde partie est consacrée aux fondamentaux de l’extensibilité d’Eclipse. Le but ici est de comprendre les points d’extensions, les notions de base des frameworks fondamentaux (SWT, JFace) et d’être en mesure de créer un plugin. On en prends pour 130 pages et 7 chapitres, et c’est curieusement plus intéressant et plus instructif que la première partie.
La troisième partie est dédiée à l’extension du workbench, mais il s’agit surtout de rentrer en profondeur dans les frameworks. Le tarif est de 7 chapitres et 230 pages. Il est vrai qu’il y a de la matière.

La quatrième partie « extending the Eclipse IDE » se focalise sur l’intégration du plugin avec le cycle de vie de l’IDE. Il en coûte 120 pages et 5 chapitres.

La cinquième partie « sujets spéciaux » couvre tout ce qui ne rentre pas ailleurs, comme l’intégration OLE DB. On aurait pu s’en passer, mais quand on aime, on ne compte pas. Ici, c’est 7 chapitres et 130 pages.

La sixième partie mérite une mention spéciale car c’est un cahier de 9 exercices guidés qui occupe les 200 dernières pages.

image

Référence complète : The Java Developer’s Guide to Eclipse, 2nd edition – Jim D’Anjou, Scott Fairbrother, Dan Kehn, John Kellerman & Pat McCarthy – Addison Wesley 2005 – ISBN : 9 780321 305022

The Java Developer's Guide to Eclipse

https://www.goodreads.com/book/add_to_books_widget_frame/0321305027?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Waiting for the Storm…

Le Storm User Group, c’est une initiative de quelques collègues autour du « big data temps réel ». Aujourd’hui, nous parlons de Storm et quelques infrastructures qui peuvent s’y connecter. Demain, il s’agira peut-être de Spark ou d’autres…

Halte là ! Je vais peut-être un peu vite ? Et d’abord, Storm, qu’est-ce que c’est ? Voilà une question à laquelle une partie de cette première rencontre va être consacrée.

Oui, Storm, qu’est-ce que c’est ?

C’est Florian Hussonois qui va répondre à cette question. Nous pourrions résumer la chose en déclarant simplement qu’il s’agit d’un Hadoop « temps réel ». Il s’agit en quelque sorte d’un middleware permettant le traitement d’évènements en mode flux.

Un (petit) peu d’historique

Storm a été développé par Nathan Marz chez BackType en 2011. La société est rachetée ensuite par Twitter qui promeut le projet et le passe en Open-Source. La première release officielle date de 2011. En Septembre 2014, le projet devient officiellement « Apache Top Level Project » alors même qu’il n’a pas encore atteint la release 1.0 !

Ecrit principalement en Clojure et en Java, ce « processeur d’évènements » est conçu pour traiter un flux de très nombreux évènements (des tuples dans la terminologie Storm), à savoir 1 millions de tuples par seconde et par noeud (1 seul coeur processeur), avec tolérance aux fautes, gestion de la scalabilité et garantie de traitement !

image

Les concepts clés

Pour bien comprendre Storm, il faut en saisir les concepts de base.

  • Le Tuple : Nous en avons parlé, il s’agit de l’unité d’information à traiter. C’est l’évènement.
  • Le Stream : c’est une séquence illimitée de tuples.
  • Le Spout : C’est un connecteur producteur de tuples. En pratiques, ce sont des composants source de données. Il en existe de nombreux types (dans le projet officiel et en dehors) pour se connecter à différentes infrastructures.
  • Le Bolt : Il s’agit du composant de traitement élémentaire. Il consomme bien entendu des tupples et peut en produire (mais pas obligatoirement). Il peut aussi se connecter à une base de données, par exemple.
  • La Topologie : il s’agit de la structure de déploiement de votre configuration Storm. Dans la pratique, il s’agit d’un graphe acyclique (DAG).
  • Groupements de streams : Si les bolts peuvent « splitter » des streams (façon CBR) ou les multicaster, ils peuvent aussi les regrouper. Il existe 7 types de regroupements.

Le parallélisme est intrinsèque à Storm. Chaque Bolt peut être instancié plusieurs fois (on les appellent « task »). Chaque tâche est prise en charge par un Executor qui correspond dans la pratique à un thread. Storm prend en charge la répartition des Executors sur des Workers (qui correspondent à une JVM). Chaque Worker devant être géré par un Supervisor. Ce dernier point est important, car les Workers peuvent tomber ! Un petit dessin vaut parfois mieux qu’un long discours…

image

Pour gérer et faire tourner l’ensemble, Storm met à notre disposition 3 briques importantes :

  • Le Supervisor : nous en avons parlé, il gère un Worker, le relançant si nécessaire, et permet de surveiller sa charge.
  • Zookeeper, qui a en charge de gérer une topologie
  • Nimbus, qui gère les masters des topologies. Il doit lui-même tourner sous supervision.

Traiter en toute quiétude

Les graphes de traitement de Storm peuvent devenir des arbres très complexes ! Toutefois Storm s’y entend pour reconnaitre si un Tuple entrant a été traité sur la totalité de son arbre. Tout d’abord chaque Tuple a son id (sur 64 bits). Nathan Marz a développé un algorithme très complexe, basé sur le XOR pour identifier si un arbre a été complètement traité. Bien entendu, chaque Bolt opère son acquittement local, c’est le « Ack ».

image

Florian passe rapidement sur Trident qui permet d’assurer une sémantique « exactement 1 » aux traitements. J’avoue que le sujet est passé trop rapidement pour moi. Peut-être une occasion de creuser le sujet ultérieurement ? Il en va de même pour la fonctionnalité DRPC.

Si vous avez raté le live et que ma prose vous laisse de marbre, voici l’enregistrement de l’intervention de Florian lui-même !

Storm et Redis chez Twitter Foot

Ce retour nous était proposé par Benjamin Houdu. Cette présentation m’intéressait d’autant plus que j’ai participé au début de ce projet. Et je dois dire que ce dont Benjamin nous a gratifié est probablement le meilleur retour d’expérience auquel j’ai pu assister !

Le projet

Comme son nom l’indique, Twitter Foot traite des flux Twitter, suivant des comptes identifiés par l’AFP (7000 comptes sur 5 ligues), pour fabriquer des timelines spécialisées et toute sortes de statistiques, comme des tendances, la détection de viralité ou de popularité.

Techniquement, les particularités de cette mise en oeuvre de Storm repose d’une part sur la connexion Twitter via la streaming API en utilisant le connecteur Hosebird, et d’autre part sur la mise en oeuvre conjointe de Redis, un base NoSQL de type clé-valeur fonctionnant en mémoire. Redis est d’ailleurs très exploité ici, car on en fait un triple usage :

  • Pour bufferiser le flux Twitter et alimenter le stream Storm. Incidemment, cela rend l’architecture plus testable, car les tests peuvent être faits simplement en peuplant Redis, sans connexion à Twitter, avec en prime la maitrise sur les données injectées !
  • Pour sauvegarder les données de référence : aussi bien la topologie que l’on va injecter dans Zookeeper que les comptes sur lesquels on a des abonnements.
  • En frontal, pour exposer les timelines résultantes et les données statistiques !

En pratique, la topologie est constituée de 3 machines abritant chacun un worker, auxquelles il faut rajouter le serveur frontal abritant le serveur Rest qui expose les services ainsi construits.

image

Et bien sûr, il y a le serveur hébergeant Redis !

Justement Redis, qu’est-ce que c’est ?

Nous l’avons dit, il s’agit d’une base NoSQL de type clé-valeur fonctionnant en mémoire. On devinera que ces choix l’orientent vers la performance, ce qui explique les autres choix techniques : elle est écrite en C et est … monothreadée ! Ce dernier choix peut paraitre curieux, mais de fait, il évite de devoir gérer les problèmes de contention. Il se justifie aussi par les excellentes performances de la base dont les requêtes sont non seulement traitées rapidement, mais aussi peu sensibles à l’augmentation de volume : la plupart des fonctions proposées ont des indices de performance en O (Log (n)) !

Parmi les fonctionnalités intéressantes de cette base, on pourra noter dans le désordre :

  • La présence d’une API de type « publish / subscribe » bien pratique entre autre pour le débug !
  • La présence de connecteurs pour un grand nombre de langages.
  • La mise à disposition de structures intelligentes : sorted sets, Z sets, etc. qui permettent non seulement de retrouver un élément, mais de sélectionner un « range » d’éléments. Une fonctionnalité qui s’avérera particulièrement précieuse dans le cas d’utilisation de Twitter Foot !
  • La présence d’un langage de script basé sur Lua qui permet d’écrire l’équivalent de procédures stockées dont l’atomicité d’opération est garantie par l’architecture monothreadée de la base !
  • L’accès en mode interactif en ligne de commande, via redis-cli pour travailler sur la base en mode non programmatique.

Storm, au coeur de Twitter Foot !

Nous n’allons pas revenir sur le descriptif général de Storm que Florian a fort bien abordé. Benjamin attire toutefois notre attention sur les changements importants survenus entre les versions 0.8.x et 0.9.x, la première dépendait fortement de Zero MQ, ce qui n’est plus le cas des versions ultérieures. Il met aussi l’accent sur l’intérêt de Storm UI d’un point de vue opérationnel, surtout pour savoir quel tâche tourne sur quel worker ! En effet, il faudra abandonner l’idée que l’on traite l’affinité des tâches sur les workers / machines, c’est Storm qui gère cela.

En fait, l’un des enseignements que tire Twitter Foot, c’est que l’administration est un volet du projet aussi important que le développement, et il faut y faire face le plus tôt possible dans le projet ! Autre difficulté, la configuration dont les changements imposent des redémarrages de topologies. C’était une contrainte trop forte pour Twitter Foot, aussi l’équipe a-t-elle traité la configuration comme un Stream traversant les Bolts !

Des fenêtres bien glissantes…

Un concept est rapidement apparu sur Twitter Foot : la nécessité de faire des statistiques sur une durée fixe, mais relative au temps présent. Ce que l’on a appelé des « fenêtres glissantes », c’est à dire entre T0 et T-n minutes (ou heures, ou jours), avec un échantillonnage représentant la résolution de ces statistiques en x minutes ! Vous pouvez aussi dire « sliding windows » pour briller dans les salons, mais ne cherchez pas sur Google, c’est un concept maison !

image

Plusieurs essais d’implémentations en ont été faites. Benjamin nous parle de deux d’entre-elles.

Tout d’abord, on peut s’appuyer sur un concept Storm : les Rolling Buffers. Ils sont plutôt complexes à mettre en oeuvre, mais ils présentent entre autre l’avantage de gérer automatiquement l’éviction des échantillons quittant la fenêtre glissante !

Autre possibilité : s’appuyer sur les ZSets de Redis. Redis permet même d’opérer des aggrégations par x minutes et donc de gérer pratiquement automatiquement l’échantillonnage ! Par contre l’éviction des vieux échantillons doit se faire programmatiquement.

Quelques mots sur la testabilité

J’ai été agréablement surpris de voir Benjamin aborder ce point finalement assez déconnecté des problématiques purement techniques de Storm (bien qu’il y ait bien sûr des corolaires techniques). Le projet a en effet mis en oeuvre tôt dans ses premières phases une approche ATDD impliquant le client et s’appuyant sur le paradigme « Given When Then » outillé avec Cucumber JVM. Cette approche a réellement permit une convergence et appréhension fine des fonctionnements attendus.

D’un point de vue technique, il a été possible de se servir de l’alimentation par Redis pour effectuer ces tests déconnecté de Twitter en injectant dans Redis des Tweets « forgés ». Autre point délicat, la nécessité de ne pas redémarrer la topologie entre chaque tests afin de garder des temps d’exécution raisonnables.

Et le monitoring ?

Nous l’avons dit, avec Storm on fait beaucoup d’administration, ce qui a quelques implications.

D’abord, plus encore qu’ailleurs, les opérations réalisées fréquemment doivent être en « push button ». Jenkins est d’une aide appréciable à ce niveau.

Le Storm Supervisor : il est indispensable, et il en faut un par machine.

L’équipe a aussi utilisé avec bénéfice Monit, un watchdog qui s’est avéré d’une grande utilité. Notre orateur est dithyrambique à ce sujet !

Du côté de Redis, c’est redis-rdb-tools qui s’est avéré indispensable. Le gros avantage est le parse des logs offline, donc sans impacter la machine de production. Dans la pratique, beaucoup d’investigations peuvent être menées à bien en différé.

Si on a réellement besoin de connaitre l’état de santé de l’instance en live, il y a … Redis Live !

Quelques mots sur le débug et les best practices

L’investigation de problèmes sur une architecture Storm peut très facilement se transformer en chemin de croix ! Il faut anticiper cela au niveau de la conception et penser les Bolts avec des responsabilités bien séparées (principe SRP de Bob Martin). En fait, Benjamin nous suggère de séparer les Bolts de contrôle des Bolts d’action !

Même chose sur Redis : bien séparer les actions d’insertion des actions de nettoyage.

Enfin, même les topologies peuvent être décomposées, une leçon qui est arrivée hélas bien tardivement sur Twitter Foot ! De plus petites topologies se testent plus facilement et sont plus robustes. Mais attention, ne pensez pas mutualiser les workers : un worker ne peut appartenir qu’à une topologie.

Autre problème bien connu, celui de l’auditabilité : comment retrouver l’origine du problème ? L’équipe Twitter Foot nous propose la technique du « Carbon dating » : injecter dans les Tuples des informations de trace des Bolts traversés !

Du côté Redis enfin, si l’aspect « sans schéma » est apparemment une liberté bienvenue, on touche vite les limites de ce manque de typage. Ici, c’est l’emploi de json-schema que vient nous recommander l’équipe.

Si vous préféreez la présentation de benjamin in extenso, ne pleurez plus, la voici !

Ce que j’en ai pensé

Je l’ai dit au début : l’orateur nous a gratifié là d’un retour d’expérience d’un niveau de qualité que j’ai rarement (jamais ?) vu !

La mise en oeuvre d’un projet avec Storm est réellement quelque chose de complexe. On perçoit cette impression rapidement, mais les dimensions de cette complexité apparaissent clairement dans cette présentation !

Mais on va plus loin ici : les voies à explorer, les points d’attention dans le projet, les outils indispensables et leur utilité, tout nous est clairement exposé. Un grand bravo !

Note de lecture : Activity in Action, par Tijs Rademakers

Note : 7 ; Un bon ouvrage au standard « in action » pour accompagner une immersion dans Activity, malgré quelques frustrations.

Activity, c’est le « spin off » de JBPM par ses créateurs. Mais, ainsi qu’il est expliqué en introduction, ce n’est pas un fork mais une réécriture complète, avec les choix de conception que l’équipe aurait voulu prendre à l’époque !

Mais revenons au livre. L’auteur est un des comiters principaux du projet, ce n’est pas non plus un auteur débutant. Tout ce présente donc sous les meilleurs auspices pour commencer. La prose est conséquente : 400 pages sur 15 chapitres distribués en 4 parties inégales. Il est temps de rentrer plus en profondeur.

Les quelques 80 pages de la première partie regroupent 4 chapitres et sont une introduction à BPMN 2.0 et Activity. On commence par une présentation générale d’activity, de son architecture et l’incontournable « hello world » précédé d’une installation basique. C’est réussi. Le chapitre suivant a pour but de nous présenter BPMN 2.0. C’est fait avec pédagogie et bien illustré, mais aussi assez superficiel et on sort de là un peu frustré. La présentation de l’outillage Activity est un peu touffue, probablement parce que cet environnement l’est aussi un peu : il manque d’homogénéité et est un peu de pièces rapportées. Espérons que cela s’améliore à l’avenir.

Avec 35 pages, le chapitre 4 est le gros morceau de cette première partie, on y débute l’implémentation de l’étude de cas, avec configuration Maven, définition de processus, implémentation de tâches en Java et tests unitaires. Honnêtement, ça fait un peu trop de chose pour être vraiment clair.

La seconde partie est consacrée à l’implémentation de processus avec Activiti, c’est donc le cœur du livre. On y compte 150 pages et 5 chapitres, ce qui le met à égalité avec la 3ème partie. Là où le chapitre 4 était un peu brouillon, le chapitre 5 reprends les choses calmement et implémente un BPM simple mais non trivial, avec une implémentation d’un script task et de différents service tasks. On va même jusqu’au déploiement. C’est bien fait et clair. Le chapitre 6 nous permet de faire des choses plus avancées (sous-processus, points de décision) et couvre aussi l’accès à JPA depuis Activity et la mise en place de listeners sur les tâches. La gestion des erreurs (en Java ou en définition de processus) est traitée avec sérieux au chapitre 7, un bon point ! C’est aussi le cas sur les options de déploiement abordées au chapitre 8, bien que je reste sur ma faim sur la façon dont l’utilisation de l’interfaçage ReST est abordé. Le chapitre 9 qui clos cette partie n’est pas mon préféré. Seul la partie OSGi m’aurait intéressée si elle avait été abordée clairement !

La troisième partie se focalise sur les aspects avancés d’Activity. Le chapitre 10 fait un peu pot-pourri entre des aspects avancés de modélisation (sous-tâches, délégation), la connexion au LDAP ou les tâches multi-instances, ça manque un peu de cohérence. Le chapitre 12 est plus « focus » car il traite d’un aspect important : l’intégration. L’utilisation d’Apache Camel et de Mule ESB font le gros de ce chapitre. C’est une bonne idée, car cela donne un exemple avec ESB et un autre avec « ESB light ». L’intégration d’un moteur de règle n’est pas nécessairement l’aspect qui m’aurait intéressé de prime abord, mais le chapitre 13 qui le traite et clair, bien écrit et même source d’inspiration. Je ne dirais pas la même chose du chapitre 14 qui traite de l’intégration avec Alfresco.

Alfresco est le principal comiter Activity et parler de cette intégration sonne comme un passage obligé, mais personnellement j’en retire peu de choses. Ca fait plutôt plaquette publicitaire. Cette partie se conclut par un passage par le monitoring de production e l’intégration avec Esper : utile, intéressant et bien fait.

La quatrième partie ne compte qu’un seul chapitre et 25 pages. L’objectif est de nous permettre de monitorer les processus en production. Concrètement on entre dans le modèle de données d’Activity et on fait un petit tour dans le Job Executor. Pas grandiose mais nécessaire.

Activity in Action fait bien le boulot, il est à la hauteur du standard « in action » de Manning. Le texte est bien écrit et les illustrations aident. Les exemples par contre sont plus problématiques : ils sont souvent non seulement complexes et volumineux, mais insuffisants tels qu’ils figurent dans le texte. Il est nécessaire d’avoir recours au code source complet.

Personnellement, mon regret est une approche très « Activity centric », où les fonctions du logiciel sont subordonnées aux hooks qu’offre le framework. Etant essentiellement conçu en ce sens, l’approche est compréhensible. Toutefois Activity possède aussi un ensemble d’API ReST permettant de l’utiliser de l’extérieur à la façon d’une appliance. Je suis d’avantage intéressé par cette architecture et je soupçonne que de nombreuses personnes le sont également. Très peu de contenu est orienté en ce sens. A mon avis, l’ouvrage aurait bénéficié d’un ou deux chapitres en ce sens, même si cela avait dû être au détriment d’autres sujets.

Malgré ces quelques frustrations, le contrat est bien rempli. Pour qui veut s’initier à Activity, voilà un excellent compagnon.

image

Référence complète : Activity in Action, Executable business processes in BPMN 2.0 – Tijs Rademakers – Manning 2012 – ISBN : 978 1 617290 12 1

Activiti in Action

https://www.goodreads.com/book/add_to_books_widget_frame/1617290122?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Swing (Les cahiers du programmeur), par Emmanuel Puybaret

Note : 4 ; Pédagogique mais trop pesant.

Cette série Eyrolles est sensée être dédiée à des ouvrages permettant de monter en compétence sur des sujets. Dans les faits, on en prend pour 500 pages. Peut-être l’auteur a-t-il été trop gourmand en essayant d’avaler de nombreux sujets ? On va voir ça !

De prime abord, le texte est découpé en 12 chapitres. Mathématiquement, cela va donner de gros chapitres, donc un découpage « à la française ». Le concept global du livre est de mener une étude de cas en mode projet, avec des itérations. Le tout à la façon extrême programming. Cela fait donc au moins 2 sujets à aborder. 3 si l’on compte le détour par SWT. Je ne compte pas toute la partie outil également aborder. Il est temps de commencer.

Le premier chapitre présente l’étude de cas : il s’agit d’un système de CAO. On évoque aussi l’approche XP (mal) qui sera utilisée et un bref exposé des cas d’utilisation (malgré que l’on soit avec XP où les user stories sont préférées). Bonne nouvelle, le tout est bouclé en 9 pages.

Il nous faut juste24 pages pour évoquer le setup de l’environnement. On s’étale trop sur Eclipse. Par contre expliquer l’usage d’une forge paraît une bonne idée, mais l’emploi de CVS est vraiment suranné tout comme l’absence de Maven (ou même de Ant). N’utilise-t-on pas d’intégration continue en Extreme Programming ?

Le chapitre 3 est consacré au match AWT vs Swing vs SWT ! Cela alourdit pas mal l’ouvrage, même s’il ne s’agit que de 40 pages, mais ce parallèle est plutôt très bien fait.

Au chapitre 4 marque le réel début du travail avec Swing. Sur deux chapitres, on met en place un arbre puis un tableau. Le travail n’est pas titanesque, mais enrober ceci de la description des manipulations sous Eclipse, de principes de refactoring, de lecture de fichiers de propriétés, etc.. gonflent ces deux chapitres à 80 pages !

Les chapitres 6 et 7 totalisent eux aussi 80 pages. Ils traitent de l’aspect dynamique de Swing, à savoir le méta pattern MVC et la gestion des commandes avec undo / redo. On a une bonne description du MVC, contrairement à ce que l’on voit souvent, et la mise en place dans l’étude de cas n’est pas encombrée de considérations annexes comme précédemment. Je regrette que l’auteur n’ait pas mentionné le « processeur de commandes » de Peter Sommerlad en référence, car la description qui est faite de ce pattern n’est pas extrêmement claire. Mais la mise en œuvre se comprend.

La gestion des graphiques 2D et 3D occupent les chapitres 8 et 9 respectivement. Avec 70 pages, le chapitre dédié à la gestion des surfaces est très complexe et difficile à digérer. De plus l’aspect fonctionnel du sujet rend le code final très difficile à appréhender. Cela sans compter les aspects frameworks (auxquels on va ajouter Abbot pour les tests unitaires). Bref un chapitre trop lourd. Avec 40 pages, le chapitre dédié à la 3D est moins dément et plus pédagogique avec de nombreux diagrammes.

Les 3 derniers chapitres peuvent être vus comme optionnels, couvrant l’enregistrement de scénarios, le copier-coller et la gestion des préférences.

L’approche pédagogique du livre est globalement bonne et un gros effort de présentation, d’illustrations et de diagrammes est fait. Mais l’étude de cas est souvent trop lourde et le texte est encombré d’aspects pas directement relatifs à Sing. C’est dommage car l’effort de l’auteur est évident.

La question de la pertinence de l’ouvrage après 5 ans se pose évidemment. Je suis partagé à cet égard, car certes cela fait un bail pour un ouvrage technique, mais je n’ai pas vu grand chose sur Swing depuis 5 ans, pas plus que je n’ai vu d’évolutions majeures durant cette période.

swing-cahiers-du-programmeur

Référence complète : Swing (Les cahiers du programmeur) – Emmanuel Puybaret – Eyrolles 2007 – ISBN : 978-2-212-12019-6

Swing (Les cahiers du programmeur)

https://www.goodreads.com/book/add_to_books_widget_frame/18488404?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Practical Apache Struts2, par Ian Roughley

Note : 4 ; Raisonnable, mais c’est bien tout.

Ce livre cible, sans surprise, le développeur Java d désirant s’initier à Struts 2. Il ne nécessite pas vraiment de connaissances préalable du développement d’application Web en java, car on est en gros pris en main dès les tâches les plus simples. Voyons ce que le livre à a nous proposer. Tout d’abord, il est de taille moyenne, avec 326 pages découpées en 10 chapitres, un départ raisonnable, avec un découpage raisonnable.

Le premier chapitre est clairement superflu, il traite de généralités sur le Web 2.0, les principes comme « convention over configuration », l’injection de dépendances, etc. Passons vite !

Le second chapitre est destiné à nous mettre le pied à l’étrier. La moitié du chapitre est consacré … à Maven 2, tandis que le reste évoque les différents fichiers de configuration nécessaires pour commencer le projet. Mais c’est un peu confus.

Le 3ème chapitre est plus théorique, et finalement un peu intéressant : il décrit la cinématique de Stuts 2 et son architecture.

Le 4ème chapitre (on est déjà à la page 70) marque le réel début du livre avec la description de l’architecture d’une application Struts 2. Voulant tout décrire, l’auteur s’égare hélas parfois un peu sur MySQL, le développement agile ou Hibernate. En fait l’objectif est de permettre d’appréhender la globalité de la construction de l’application, pas seulement Struts 2.

Au chapitre 5, on aborde tout ce qui concerne la manipulation de données : modèle, actions, updates, templates, etc. C’est un gros chapitre avec 55 pages.

Les chapitres 6 et 7 abordent des aspects plus avancés de struts : Les workflows (chapitre 6) et la sécurité (chapitre 7).

Le chapitre 8 revient sur un problème récurrent : l’implémentation de recherches et l’affichage paginé de liste de résultats. Pas grand chose à en dire non plus.

Le chapitre 9 fait état de sujets plus originaux : l’intégration de flux RSS, l’intégration illustré par une intégration Google Maps (et donc du geocoding) et l’appel de Web Services.

Il était incontournable qu’Ajax soit mentionné. C’est chose faite au dernier chapitre. Le toolkit Dojo est intégré à cet effet. Mais curieusement, un exemple d’intégration avec GWT est également montré (mais en 5 pages seulement). Pourquoi faire cela ? Mystère…

Bref, le bouquin fait le boulot. Il n’y a pas de quoi s’extasier non plus. Ce texte ne fera pas de vous un gourou de Struts 2. Pour ma part, j’aurais aimé un texte condense en 200 à 250 pages.

image

Référence complète : Practical Apache Struts2, Web 2.0 projects – Ian Roughley – Apress 2007 – ISBN : 978 1 59059 903 7

Practical Apache Struts2 Web 2.0 Projects

https://www.goodreads.com/book/add_to_books_widget_frame/1590599039?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Lucene in Action, par Otis Gospodnetic & Erik Hatcher

Note : 6 ; Fait le boulot comme attendu, contrat rempli.

Lucene est le grand classique, pratiquement l’unique moteur d’indexation et de recherche full texte en open source, du moins dans le monde Java. Il était normal qu’un volume de la sérié « in action » de chez Manning lui fut consacré. Voyons en pratique ce qu’il en ressort.

Tout d’abord le texte compte pratiquement 400 pages découpées en 10 chapitres. Cela me semble au premier abord plutôt volumineux et constitue des chapitres qui seront en moyenne plus long que ce que j’apprécie en général. Au moins, on va pouvoir les passer en revue.

Le premier chapitre comme il est coutumier dans cette série présente la problématique de la recherche plein texte, la réponse de Lucene et ses alternatives. Le tout est bouclé en 27 pages et c’est une entrée en matières plutôt sympathique.

On rentre très vite dans le dur avec le chapitre 2 consacré à l’indexation. Long de 40 pages il évoque la fabrication d’index et ses différentes variantes : ajout ou mise à jour de documents, indexation en mémoire, verrouillage de l’index pendant l’opération, multithreading, etc.. Chaque fois la chose est illustrée par un fragment de code assez clair et focalisé. On notera également l’approche progressive des auteurs, car on n’évoque pas à ce stade l’intégration de cette indexation dans une application !

Justement, l’intégration dans une application, c’est l’objet du chapitre 3. Long de 32 pages, celui-ci aborde les différentes options de recherche depuis une application. C’est toutefois un peu plus dense et fouillis que le chapitre précédent, entre autre quand on aborde le système de scoring de Lucene qui aurait certainement plutôt mérité son propre chapitre.

Si ces 3 premiers chapitres constituent les briques de base de Lucene, le chapitre 4 consacré aux analyses, donc à la constitution de termes à partir de l’indexation est d’un abord plus ardu. 45 pages lui sont consacrées. L’abord n’est pas simple, le sujet étant présenté de manière un peu trop touffue encore. Là aussi un découpage en deux chapitres en présentant les aspects de base d’abord puis les aspects plus complexes (synonymie, distance, analyse des langues asiatiques, etc…) aurait été bienvenu.

Le chapitre 5 traite des techniques de recherche avancées. Bien que les 45 pages de cette partie en fasse aussi un chapitre conséquent, celle-ci est plus abordable car les thèmes sont abordés successivement : tri, span queries, filtrages, sécurisation, utilisation d’index multiples, recherches parallèles, vecteurs de ternes.

Mettre en œuvre des recherches customisées est le thème du chapitre 6 qui occupe 27 pages. On y apprend à mettre en œuvre une heuristique particulière de recherche avec le « hit collector » mais aussi à y tester les performances.

Le chapitre 7 dédié au parsing de différents types de documents débute la seconde partie de l’ouvrage. Sur 43 pages on y aborde le traitements de formats de documents tels que le XML/HTML, le Word ou le PDF. Bien sûr les exemples mettent en œuvre des librairies tierces pour prendre en charge ces formats de manière native (PDFBox, TextMining.org, JTidy) ce qui est aussi une occasion d’aborder ces librairies.

Les 34 pages du chapitre 8 « Tools and extensions » sont un peu le grand fourre-tout de ce volume. Beaucoup d’outils tiers ou de la sandbox sont abordés, c’est la bonne nouvelle. Néanmoins, ces outils sont présentés de manière superficielle, mais cela suffit peut-être. En effet, ce genre de choses bouge très vite, je ne suis pas certain que ces outils soient toujours pertinents aujourd’hui. Il faudrait comparer cela à la seconde édition du livre parue depuis.

Le chapitre 9 présente les différents portages de Lucene. 12 pages seulement sont consacrés au sujet. Je pense aussi qu’il n’est pas utile de s’étendre sur le sujet, les mentionner et en faire une présentation succincte est déjà bien !

Avec 62 pages, le chapitre 10 présentant des cas d’étude est le plus long du livre. Il est le fruit des contributions d’acteurs de projets tiers mettant en œuvre Lucene. Du coup le niveau d’information varie beaucoup d’un projet à l’autre. Il est très bas niveau pour jGuru, tandis que SearchBox reste au niveau de l’architecture., plus fonctionnel sur XtraMind, etc…Disons que c’est la minute culturelle du livre. Mais c’est fort intéressant !

Le livre remplit bien le contrat de la série « in action ». Il est aussi sans surprise, ni bonnes ni mauvaises. Mais on a au moins la sensation que les auteurs n’ont pas cherché à faire du remplissage. Sans être indispensable pour aborder Lucene, il apportera sans nul doute des éclairages dans sa mise en œuvre. Cette édition n’est plus sur les rayons car une seconde édition est sortie depuis, mais vous n’auriez pas perdu votre argent.

image

Référence complète : Lucene in Action – Otis Gospodnetic & Erik Hatcher – Manning 2005 – ISBN : 9781932394283

Lucene in Action

https://www.goodreads.com/book/add_to_books_widget_frame/1932394281?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : Swing, la synthèse par Valérie Berthié & Jean-Baptiste Briaud

Note : 6 ; Une approche simple et claire pour débuter avec Swing.

Ecrire la note de lecture d’un ouvrage 11 ans après sa parution est un exercice difficile, peut-être même un peu malhonnête. Je vais toutefois tenter l’exercice.

Ce livre est publié dans une collection qui n’a jamais fourni des morceaux d’anthologie de la littérature informatique française. Tant pis. Ici nous avons 325 pages sur 7 chapitres et 2 annexes, avec 280 consacrées au corps du livre, donc des chapitres assez importants.

Le premier chapitre est consacré aux principes fondamentaux de Swing et pèse tout de même 76 pages ! C’est en fait une bonne surprise : après avoir expliqué la facette historique menant de AWT à Swing, on aborde les différents composants de manière très pédagogique, avec des morceaux de code simples et même des diagrammes UML !

Le second chapitre est exclusivement focalisé sur les Layout et se satisfait de 35 pages. Cela reste très pédagogique, bien qu’un tout petit peu plus confus sur la fin.

Avec le chapitre 3, on aborde les évènements. Les 35 pages consacrées au sujet sont plus difficiles à aborder. On retrouve un bon équilibre entre le texte et le code, mais peu de diagrammes et c’est dommage car les auteurs excellent à les produire.

Le chapitre 4 traite des composants complexes : arbres, tableaux, etc… le tout sur 50 pages. Bref tout ce qui contient des cellules y est traité. On y retrouve la clarté des premiers chapitres, et c’est tant mieux !

Au chapitre 5, on aborde les composants traitant du texte. Cela couvre également 50 pages. Le tour d’horizon est assez complet, depuis les différents composants concernés jusqu’aux actions et évènements disponibles en passant par la configuration des composants, comme celle des polices de caractères. Intéressant.

En 20 pages, le chapitre 6 traite du drag & drop à l’aide d’un exemple enrichi progressivement. Le sujet est toujours hélas un peu complexe. Ce chapitre ne fait pas exception.

Les 13 pages du chapitre sont consacrées aux nouveautés de … java 1.4 ! Eh oui, il n’y a pas de miracle, le livre est ancien et c’est ici que cela apparaît clairement. Qu’importe le reste de l’ouvrage donne à manger pour celui qui débute avec Swing !

image

Référence complète : Swing, la synthèse – Valérie Berthié & Jean-Baptiste Briaud – Dunod 2001 – ISBN : 978 210 005237 3

Swing La Synthèse   Développement Des Interfaces Graphiques En Java

https://www.goodreads.com/book/add_to_books_widget_frame/2100081799?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Note de lecture : The Definitive Guide to SWT and JFace, par Rob Warner & Robert Harris

Note : 3 ; Quand même un peu mieux que la Javadoc. Mais pas tellement plus…

Voilà un pavé à 800 pages qui fleure bon le livre de commande. Pourtant le périmètre de l’ouvrage est volontairement limité aux frameworks de base d’Eclipse : SWT et JFace. On ne parle pas de développer des plugins et encore moins une application RCP. Aucunement question de s’appuyer sur les points d’extension du Workbench ni autre plaisanterie du même acabit… Voyons comment on en arrive là.

Le livre est découpé en deux parties (trois en fait) de taille inégales :
La première partie « Getting Ready » couvre le setup de votre projet applicatif au bout de 2 chapitres. Cela dit, on ne s’étale pas et c’est bouclé en 25 pages en tout.

Dès la seconde partie, on passe aux choses sérieuses avec SWT. En fait, c’est le gros du bouquin : 10 chapitre sur un peu plus de 500 pages. Tout est abordé de façon logique et je dirais même classique. On se rend vite compte qu’il y a principalement 3 choses que noircissent la papier : de grosses copies d’écran, des listing de codes un peu trop extensifs et une reformulation de la javadoc ! C’est un peu dommage, car les explications qu’il y a entre sont plutôt claires.

La troisième partie couvre logiquement JFace. 8 chapitres sur 280 pages lui sont consacrés. Même recette ici, on ne change pas une équipe qui gagne.

Je ne vois hélas guère de raison de s’enthousiasmer pour ce livre. Il ressemble vraiment trop à un texte que l’on paie au poids. C’est dommage car les auteurs savent se montrer clairs dans leurs explications. En le travaillant plus et avec une réelle volonté de rendre tout ça plus léger, ils auraient pu en faire quelque chose de bien plus acceptable de moins de 300 pages.

Bref, son âge canonique devrait déjà vous dissuader de l’acquérir ou même de le lire, mais hélas le problème est aussi dans le contenu.

image

Référence complète : The Definitive Guide to SWT and JFace – Rob Warner & Robert Harris – Apress 2004 – ISBN : 9781590593257

The Definitive Guide to SWT and JFace

https://www.goodreads.com/book/add_to_books_widget_frame/1590593251?atmb_widget%5Bbutton%5D=atmb_widget_1.png&atmb_widget%5Bhide_friends%5D=on

Carnet de route : Agile France 2014 (3/4)

Suite du compte rendu d’Agile France, après la journée de Jeudi disponible ici et ici.

De bon matin…

De bon matin, ce n’est pas moi. J’arrive à temps pour le café et discuter un peu avec les autres. Mais quand j’arrive, un petit groupe se livre déjà à des exercices de Qi Gong.

image

Je retrouve les autres dans la salle commune. On discute, Alex Tweet. Business as usual…

image

Assez plaisanté ! La journée va commencer, place à la keynote !

Coaching Teams Through Change

Rachel Davies nous avait déjà gratifié d’une session il y a peu lors du ScrumDay. Fort heureusement, ce ne fut pas la même. J’ai d’ailleurs préféré cette keynote.

Rachel travail pour Unruly, une société spécialisée dans le « social media advertising ». C’est un domaine où les spécifications changent véritablement tous les jours. L’objectif est ainsi de déployer effectivement tous les jours !

image

Le début d’un changement

Au début les départements produit et développement étaient deux directions séparées. C’est le départ du directeur produit qui a permit d’enclencher un changement de structure.

Ce changement, c’est l’organisation en équipes de 3 à 5 personnes pour développer le produit. Et pas seulement développer : ces équipes prennent en charge la totalité des activités entourant le développement : l’écriture des user stories, les tests, etc. Ce sont eux qui vont solliciter les différents interlocuteurs (produit, marketing, commercial) quand cela s’avère nécessaire. Pas de product Owner qui est la seule voix du client, l’équipe va parler directement à tous les interlocuteurs ! Parmi ces interlocuteurs, nombre d’entre-eux ne sont accéssibles qu’à distance : l’équipe utilise Google Hangout pour communiquer. La conversation s’engage avec les interlocuteurs pour trouver la plus petite chose utile à construire, ce qui nécessite de prendre en compte tous les point de vue.

Lone rangers et development owners

Tout le développement est réalisé en binômes. Mais les équipes sont constituées d’un nombre impair de personnes ! En fait, par rotation, l’une d’entre-elle est le « lone ranger ». Elles s’occupe de diverse choses dans l’équipe, mais pas du code de production. C’est aussi à cette personne que les intervenants extérieurs à l’équipe s’adressent, afin de ne pas perturber les binômes en train de travailler.

L’équipe a aussi développé l’idée de « owner of the development area » : un développeur plus expert au sein d’un sous-ensemble fonctionnel. C’est lui qui élabore une proposition par rapport à un besoin exprimé.
Les propositions sont traitées en planning meeting. Celui-ci n’est pas un planning meeting classique XP : seule la priorisation des propositions y est traitée, il n’y a pas d’engagement de charge. Ces planning sont donc très courts : ils n’excèdent pas 30 minutes !

Gold card

A l’image de ce que Kniberg décrit pour Spotify, Unruly fait des efforts particuliers par rapport au bien être des équipes. Outre divers évènements sociaux, la société applique la politique du 20% free time inspirée de Google (bien qu’elle disparaisse progressivement de Google, justement). Ici elle s’appelle « gold card day » et sert de sources d’inspiration pour creuser de nouvelles idées.

Ce que j’en ai pensé

Sans être exceptionnelle, cette présentation nous offre l’opportunité d’avoir un retour sur une organisation d’équipe différente de ce que l’on voit aujourd’hui :

  • Les itérations s’estompent au profit de la déliverie continue, mais des points de priorités réguliers contrebalancent l’effet « court terme » du flux.
  • Pas de « product owner » ici : c’est l’équipe qui fait le lien avec les divers interlocuteurs. Le périmètre de responsabilité de l’équipe s’accroit, mais on évite ainsi l’effet paravent du PO !

Je change mon programme à la dernière minute. Je choisis en 15 secondes d’aller à une présentation résolument technique. Grand bien m’en a pris !

Le mythe du framework agile

Jean-Baptiste Dusseault vient mettre fin à quelques idées reçues concernant ces frameworks qui doivent nous agilifier / faciliter la vie. Au départ de ce « ras le bol » un titre de livre : Agile Web Developement with Rails ! Même co-écrit par l’un des signataires du manifeste agile (et par l’auteur de Rails), ll y a un problème ici. Probablement plusieurs même. Le premier est la taille du livre : près de 500 pages !

Le framework maison

Mais commençons par le commencement. Et le commencement, puisque nous parlons ici de frameworks « full stack », c’est le fameux framework d’entreprise. Un bon point : nous n’avons que trop rencontré ces pantalonnades. Lâchons-nous, ça va faire du bien !

image

Le but de ces frameworks, c’est d’avoir le « meilleur du moment », tout bien branché ensemble. On met les pantoufles, on débranche le cerveau, et l’on peut tranquillement produire plein d’applications en un tournemain !
Sauf que ça ne se passe pas comme ça. Ces braves frameworks transforment notre vie en enfer !

Citons dans le désordre :

  • Prévus pour être simples, ils s’avèrent en fait ultra-compliqués ! Peut-être leur conception et leur réalisation par des « équipes transverses » explique-t-elle quelque chose ?
  • Ils sont difficiles à tester et très bugués. Là encore, leur réalisation détachée des projets n’a pas contribué à leur testabilité. Utilisés uniquement par quelques projets de l’entreprise (au mieux) le « durcissement » du framework n’a jamais vraiment eu lieu…
  • pas de support : souvent les équipes ayant réalisé le framework sont parties depuis longtemps…

Qu’en est-il des « full stack » reconnus ?

Ici on parle des rails, Play, etc… Ils nous font la même promesse d’accélérer les développement du sol au plafond. En vérité, ils prennent des décisions d’architecture pour nous ! Jean-Baptiste va plus loin : en déléguant les choix d’architecture au framework, on laisse celui-ci nous utiliser !

Nous n’utilisons pas les frameworks “full stack” : ce sont eux qui nous utilisent.

Ce biais a des conséquences, on va le voir bientôt.

D’où vient leur succès ? Ils permettent de faire très vite 80% de l’application. Mais on galère sur les 20% restant ! Généralement, la réalisation en suivant le tutorial va vraiment vite.

Hélas, ils encouragent certains comportement. La partie « basse » entité et persistance est plus ou moins câblée. Il n’est pas possible d’y intervenir facilement. Et les entités ressemblent beaucoup aux tables de la base de données (ça rappelle les outils RAD client/serveur). On hérite donc d’un couplage vertical sur la base de données.

En fait, le seul endroit où l’on peut réellement raccrocher du code, c’est le contrôleur ! On l’accroche comme on peut. Et si des comportements communs apparaissent dans le code tartiné sur deux contrôleurs, le seul moyen efficace de le partager est le copié-coller ! Beurk !

Bref nous obtenons :

  • Des architectures monolithiques.
  • Des frameworks optimisés pour l’écriture de code … mais pas pour sa maintenance !
  • Des couplages forts avec la représentation et la base de données.
  • De grosses difficultés pour sortir des clous via des « plugins » et autres joyeusetés du genre qui ont de grosses courbes d’apprentissage.
  • Une testabilité rarement au rendez-vous.

Mais alors, c’est quoi un framework agile ?

Plutôt que de framework agile, parlons d’architecture agile, et des propriétés qu’elle devrait avoir.

  • Elle doit nous permettre de retarder les décisions
  • Elle minimise les couplages.
  • Elle est facile à changer.Elle est testable (via TDD et ATDD)

Une proposition et des inspirations

Pour Jean-Baptiste Dusseault, une telle architecture c’est :

  • Au centre un véritable modèle du domaine d’inspiration DDD, comme les proposent l’architecture hexagonale d’Alistair Cockburn ou la Clean Architecture de Bob Martin. Ce modèle ne dépend de rien et ne connait pas la persistence ni aucun système tiers, mais expose une API métier.
  • Une couche « commandes » implémentant les cas d’utilisation du modèle du domaine. Des idées que l’on retrouve dans la Lean Architecture de Jim Coplien.
  • Au-dessus un couche d’accès type CQRS dialoguant en asynchrone avec la couche commande et routant différemment les évènements commande (vers la couche commande) des requêtes qui sont adressées directement à la couche d’accès à la base de données.

Bien sûr le postulat de cette architecture, c’est que le métier est au centre des préoccupations. On n’évoque pas non plus l’architecture en micro-services qui me semble pourtant adaptée mais peut-être pas facile à concilier avec une architecture hexagonale…

La présentation de Jean-Baptiste est évidemment en HTML5 et elle est accessible en ligne ici.

Ce que j’en ai pensé

Cette session est une agréable surprise. Si le bashing des « frameworks agile » ne fait que confirmer ce que je pensais, les idées développées sur l’architecture agile me font beaucoup plus réfléchir, pour ne pas dire qu’elles soulèvent mon enthousiasme !

Comment j’ai développé mon muscle de l’amélioration continue en faisant mes courses

Ayant décidé de bouleverser mon programme, je n’ai de nouveau que 2 minutes pour changer mon programme. De nouveau, c’est une bonne pioche avec la session de Cyrille Deruelle !

Tout d’abord : pourquoi faire des exercices d’amélioration ? Pour que cela devienne une habitude, rendre cela naturel. Et Cyrille s’est livré à cet exercice en faisant ses courses du Samedi : c’est drôle et instructif !

image

Bien sûr tout ça n’a pas très bien marché du premier coup (d’où la nécessité de s’améliorer). Au départ, Cyrille a essayé d’impliquer son épouse (Product Owner des courses) dans la résolution des problèmes qu’il rencontrait. C’est une première leçon :

Les gens se foutent de la manière dont nous résolvons les problèmes.

Au hasard des améliorations, on va trouver :

  • « t’as rien oublié » … où comment suivre que l’on a tout acheté ? A l’aide d’une liste de courses et d’un gros feutre noir (le stylo fin ne convient pas).
  • Grouper les courses par catégorie : afin d’optimiser le parcours dans le magasin.
  • Prendre une photo des rayonnages pour les produits compliqués … afin de permettre à son épouse d’indiquer le produit souhaité. Le choix de la lessive a été vaincu ainsi !
  • Gérer les dates limites de consommation en les pré-calculant par rapport aux courses suivantes : afin d’éviter les erreurs pendant les courses.
  • Sortir des éléments du process : Les packs d’eau, c’est ingérable ! Alors on ne les sort du processus standard et on fait de temps en temps des ravitaillements en eau (en grande quantité) !

Les conclusions de Cyrille

  • Mes problèmes sont mes problèmes : Il n’est pas possible de s’en décharger sur d’autres personnes.
  • Il n’y a pas de choses simples : l’amélioration continue est une quête !
  • Les actions d’amélioration sont fragiles et difficiles ; c’est une discipline de tous les jours.
  • Mesurer l’impact d’un problème, c’est déjà 50% de la résolution

Enfin parfois, les améliorations ne sont pas possible, c’est le CCMCCC : C’est Con Mais C’est Comme Ca !

Grâce aux actions d’amélioration, Cyrille n’a pas seulement rendu son processus de meilleure qualité et plus efficace, il l’a aussi rendu fun !

Ce que j’en ai pensé

Une très bonne session : amusante et instructive. Bravo !

Refactorer du Legacy

Pas besoin de changer de salle pour la session de Johan Martisson. J’ai rencontré Johan lors du ScrumDay 2014. Ou plus exactement, Jean-Laurent de Morlhon me l’avait présenté. D’ailleurs Jean-Laurent était là à cette session résolument intimiste orientée craftmanship, avec des vrais morceaux de « live coding ».

image

Johan nous parle et nous démontre son approche de la reprise en main du code legacy, à l’aide de la librairie ApprovalTests. Pour résumer l’approche en quelques points :

  • On construit un harnais de tests résolument temporaires de manière rustique mais rapide.
  • On construit de manière assez brutale des combinaisons de conditions d’entrée pour couvrir une combinatoire de cas couvrant l’espace du problème.
  • On exécute une première fois les tests pour constituer la référence, sans se soucier de la justesse des résultats : il s’agit juste du comportement courant de la librairie.
  • On vérifie la stabilité du comportement du soft en comparant les résultats par rapport à la référence.
  • Au fur et à mesure du refactoring, on construit des tests unitaires définitifs. On peut envisager de se débarrasser définitivement des tests temporaires, de manière progressive.
image

Ce que j’en ai pensé

Au début de la présentation, je mes suis demandé où Johan essayait de nous emmener et j’ai pris conscience avec un peu de retard de l’efficacité et de la rapidité avec laquelle Johan mettait en place son harnais de tests ! Je dois dire que c’est très convainquant. Une petite vidéo pour vous en convaincre.

J’avais prévu d’être un peu plus long sur le descriptif de ce que Johan nous a montré avec l’outil, mais il le fait mieux que moi sur son blog. Je vous invite donc à le lire.

Pause déjeuner

Par une curieuse coïncidence, c’est de nouveau avec Jean-Luc Lambert que j’ai échangé lors de cette pause. Et nous avons parlé éducation et « génération Y ». Jean-Luc évoque avec enthousiasme le challenge que représente l’enseignement avec cette population.

  • Elle ne prend pas pour acquis les propos de l’enseignant. Le cours magistral a une vertu pour le moins limitée.
  • Ils sont « multi-tâches ». C’est assez déroutant, mais il faut faire avec !
  • Ils sont réceptifs aux jeux et aux exercices libres. Les techniques type « from the back of the room » leur sont bien adapté.
  • Ils ont beaucoup d’autonomie et sont entreprenant.
  • Ils ne se sentent pas beaucoup d’attache ni de fidélité pour la société pour laquelle ils travaillent.

Voilà pour cette dernière matinée. Je vous retrouve très bientôt pour la dernière partie de cet Agile France 2014 !