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.

Lire la suite

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

Lire la suite

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.

Lire la suite

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 !