Note de lecture : Au cœur de Corba avec Java, par Jérôme Daniel

Note : 7 ; Corba clairement expliqué

Dans les années 90, Corba régnait en maître sur les applications distribuées ou peu s’en faut. Celui-ci, paru vers la fin de l’ère Corba, a pour but de nous initier complètement à Corba en s’appuyant sur une implémentation Java. Mais c’est avant tout un livre sur Corba. L’auteur, Jérôme Daniel est l’architecte de l’ORB JavaORB (il est également celui de OpenORB, son successeur). Il est donc logique que les exemples s’appuient sur ce broker.

L’ouvrage est assez conséquent, puisqu’il compte 380 hors annexes, structurées en 4 parties pour un total de 20 chapitres. La première partie se focalise sur les mécanismes de base, mais la facture est quand même de 6 chapitres pour 115 pages ! Le premier chapitre traite des environnements répartis et plus particulièrement de l’invocation à distance (donc de RPC) et tout ce qui va avec : fiabilité et sécurité. Le second chapitre, c’est un peu le « hello world » avec Corba, en y incluant de l’IDL, l’implémentation client et serveur jusqu’à l’exécution. C’est très bien fait. L’IDL, justement, va être utilisé opérationnellement au chapitre 2 durant lequel nous allons développer un véritable serveur Corba. Même si cela reste simple, on y est très bien guidé. Le 3ème chapitre est un peu en décalage des 2 premiers, car il prend des allures de manuel de référence IDL, bien qu’étant moins sec que ce qu’il est convenu de croiser en la matière.

En abordant le chapitre 4, on prend bien conscience que l’IDL est au cœur de Corba, car c’est encore de cela qu’il est question ici, sur les aspects avancés, en continuité directe du chapitre 3. Le chapitre 5 continue dans la même voie, mais en abordant des sujets qui font la jonction avec les ORB : identifiants, contextes d’opération, etc. Alors que ce chapitre devrait redevenir concret à l’image des deux premiers, cela reste hélas pas mal abstrait ! Cette partie se referme sur un chapitre 6 évoquant les références, contextes et autres URL. Il s’y trouve pas mal de code, ce qui mitige un peu le côté aride du propos.

Lire la suite

Note de lecture : Seriously Good Software, par Marco Faella

Note : 4 ; Le “seriously” est à prendre très au sérieux !

Ce texte n’est pas très facile à classer entre Java et Craftsmanship. S’il est résolument orienté sur la plateforme Java, c’est tout de même sur les principes d’implémentation (et un peu de conception) que l’auteur met l’accent. L’auteur, parlons-en, est professeur d’informatique à l’université de Naples. De fait, sans en avoir l’austérité, le texte a quelques ressemblances avec un support de cours.

Voyons un peu ce qu’il en est. L’ouvrage compte 9 chapitres répartis sur 2 parties très inégales, pour un total de 280 pages. On le voit, ce sont des chapitres relativement conséquents, en moyenne supérieur aux 20 pages par chapitre qui m’a toujours semblé un bon compromis. La première partie compte deux chapitres, couvrant 45 pages. Le chapitre introductif traite de la qualité ou plus exactement des qualités attendues d’un logiciel. Ce seront les points successivement développés dans les chapitres suivant, puis l’étude de cas qui nous suivra tout au long de l’ouvrage est introduite.

Le second chapitre introduit l’implémentation de référence. Une implémentation qui ne cherche à optimiser ni la performance ni l’emprunte mémoire. Toutefois l’approche adoptée pour analyser l’un et l’autre est présentée ici, grâce à cette version facilement appréhendable. Bien sûr c’est la notation O popularisée par la STL qui est utilisée pour les performances. On sent déjà le côté « support de cours » dans ce chapitre par ailleurs pas désagréable à lire.

Lire la suite

Note de lecture : Java by Comparison, par Simon Harrer, Jörg Lenhard & Linus Dietz

Note : 6 ; Craftsmanship, niveau junior

Le code de qualité, il faut bien commencer à l’écrire un jour. Et ce jour, ce peut être sur les bancs de l’université. C’est ce qui a motivé en premier lieu l’écriture de ce texte. Contrairement aux classiques du Craftsmanship qui s’adressent au développeur aguerri, celui-ci s’adresse au débutant et la progression des chapitres reflète cela.

C’est un texte assez court, qui n’excède pas 165 pages et compte 9 chapitres au long desquels sont distillés 70 exemples, toujours présentés de la même façon : une page avec le code « avant » auquel fait face le code « après » sur la page en vis-à-vis, agrémenté de quelques explications, mais le tout contenu dans ces deux pages. Le premier chapitre adresse des basiques de clarté du code, sur une vingtaine de pages, soit 8 exemples, qui vont des formulations booléennes à la notion de symétrie du code. Tout cela reste très simple, mais nécessaire à couvrir pour le débutant. On remarquera toutefois une approche « opiniated » qui persistera tout au long du livre, mais cela me semble normal.

On passe la seconde avec le second chapitre. Cela continue sur des questions de clarté, par exemple avec les énumérations, mais aussi de code sain, notamment à propos des itérations. Tout ceci est couvert en 8 exemples également. Alerte maximum pour le chapitre 3 dédié aux commentaires ! Ce sont même 10 exemples qui figurent ici. Mais, oh soulagement, les 4 premiers nous suggèrent d’éliminer les commentaires redondants. Finalement on fait dans le bon sens.

Lire la suite

Programming Concurrency on the JVM, par Venkat Subramaniam

Note : 5 ; Essentiellement intéressant pour la programmation par acteurs, bien que le traitement du sujet soit largement perfectible.

Ce livre a attiré mon attention, car il traite de programmation concurrente, non spécifiquement en Java, mais sur différents langages de la JVM. Dans la pratique, on parle presqu’exclusivement de Java et de Scala. Clojure parvient à se ménager une petite place, surtout que STM vient de là, mais JRuby et Groovy sont abordés de manière vraiment très succincte en fin de livre.

Du livre, parlons-en : il s’agit d’un texte de 250 pages découpé en 5 parties (la 5ème ne contient qu’un court chapitre de conclusion) et totalisant 10 chapitres. Le premier chapitre est une courte introduction illustrée par du multithread « de base » en Java. Il nous présente le thème récurrent du texte : « shared mutability is pure evil ! ».

La première partie s’intitule « stratégies for concurrency » et se contente de 2 chapitres sur 30 pages. Le chapitre 2 « division of labour » évoque le mapping des tâches avec des threads dans différentes configurations applicatives. C’est un sujet instinctivement naturel mais bien illustré ici. Le texte ayant pris quelques rides, il ne pouvait évoquer les co-routines popularisées par Go et désormais disponibles sur la JVM. Au chapitre 3, on prépare la seconde partie en évoquant, hélas de manière légère, des options de conception liées à la gestion des états, et plus précisément l’impact de la mutabilité. Un chapitre un peu décevant.

Lire la suite

Note de lecture : Java Beans : Guide du programmeur, par Robert Englander

Note : 6 ; Voyage tranquille au temps des Java Beans

Les Java Beans sont un sujet des premiers temps de Java, il en est devenu désuet. Alors que JEE était en train de promettre aux oubliettes ce fier modèle de composant, Spring lui aura offert une seconde jeunesse. Par un étrange trait du destin, c’est JEE qui se sera offert son ticket pour le musée d’archéologie !

Bien que le sujet soit assez basique, Robert Englander nous aura produit un ouvrage de 260 pages ! Celui-ci compte 10 chapitres que nous allons explorer. Le premier chapitre nous propose sur une dizaine de pages un tour d’horizon des propriétés des Java Beans, mais sans réellement rentrer dans ce qu’ils sont réellement. C’est assez superficiel. Beaucoup plus sérieux, le second chapitre explore en profondeur le modèle d’évènements des Java Beans. Passé de mode (et je suis gentil), ce chapitre est l’un des intérêts de ce texte vieux de plus de 20 ans. D’autant que le sujet est traité de manière exhaustive et avec pédagogie. Je regrette juste que ne soit pas adressé la représentation interne et le mécanisme de dispatching de ces évènements. Oh nostalgie, le chapitre se termine par AWT (paix à son âme) grand consommateur d’évènements Java Beans.

On continue sur le thème des évènements au chapitre 3, avec les adaptateurs d’évènements (qui sont en fait des listeners) et une pincée de réflexion pour rendre cela générique. Et toujours la déclinaison AWT en fin de chapitre. Eh oui, en 1997, c’était important. Le chapitre n’est pas grandiose, mais bien expliqué et bien illustré. Place aux propriétés au chapitre 4. Le chapitre est assez exhaustif sur la question, avec entre autres les évènements de changement de propriétés.

Lire la suite

Note de lecture : Les JSP, par Eric Chaber

Note : 2 ; Un peu d’arnaque à l’horizon

Eh bien oui : je cherchais un texte assez simple et facile d’accès pour écrire quelques pages JSPs, juste de quoi me faire de l’auto-formation. Un livre ne français m’était apparu être un bon choix. Ce ne fut pas le cas, nous allons voir pourquoi.

L’ouvrage est assez modeste avec ses 190 pages sur 10 chapitres. Cela commence vraiment très bas avec les deux premiers chapitres. Certes ils sont courts, mais je ne m’attendais pas à ce que moi lecteur je sois pris aussi bas qu’une explication sur le langage java s’impose… Par comparaison, les 20 pages du troisième chapitre paraissent costauds, surtout que l’on passe en un clin d’œil de la présentation de Java EE aux JSP. Au moins, même s’il ne fait pas rêver, ce chapitre nous montre-t-il les fondements des JSP !

Place au chapitre 4 … et à la connexion aux bases de données. Car l’auteur fait tout depuis les pages JSP, y compris du code JDBC. La mise en tableau des résultats fait partie du package, on s’interrogera juste sur la pertinence du design… Le chapitre 5 est court et nous permet de reprendre notre souffle. Il traite exclusivement des cookies. Au chapitre 6 on attaque du lourd avec les Java Serveur Tags. Malheureusement, ce chapitre ressemble surtout à un manuel de référence où l’auteur nous dispense de temps à autre (visiblement à contrecœur) quelques exemples. Bref, passons.

Lire la suite

Note de lecture : Camel in Action, par Claus Ibsen & Jonathan Anstey

Note : 7 ; La qualité des grands classiques “in action”

La série « in action » chez Manning est en principe une recette éprouvée. Elle doit permettre de rencontrer des ouvrages solides, dont les sujets sont bien abordés de manière progressive et illustrée en se salissant les mains. Malheureusement trop de titres échouent aux portes des critères qualité. Rien de tout cela ici. Le texte est solide, abondement pourvu d’illustrations (parfois trop, certaines ne servent à rien) et d’exemples de code.

Camel est un framework recelant de nombreuses facettes, parfois insoupçonnées. Les auteurs les abordent de manière systématique avec un bon niveau de profondeur. Voyons cela. D’abord ce volume nous assène 460 pages hors annexes. Sérieux me direz-vous ? La seconde édition sortie depuis accuse elle dans les 900 pages ! Revenons à celle-ci. L’ensemble est structuré en 3 parties pour un total de 14 chapitres. Oui, cela signifie donc des chapitres plutôt conséquents.

La première partie « first steps » est aussi la plus courte : moins de 60 pages avec seulement deux chapitres. La première partie « Meeting Camel » nous permet de faire le tour du propriétaire et de découvrir notre premier « hello world » de manière très agréable. C’est aussi l’occasion de faire connaissance avec les concepts de base de Camel. Les Enterprise Intégration Patterns (EIP) sont même évoqués mais sans plus. Coup de zoom au second chapitre « Routing with Camel » qui va en fait assez loin dans les différents concepts de routage, allant jusqu’au multicast ! L’étude de cas abordée ici n’est pas utilisée au fil de l’ouvrage de façon mortelle, mais au moins sert-elle de point d’ancrage. Les auteurs switchent aussi beaucoup entre le « Java DSL » et le « Spring DSL » allant jusqu’à utiliser le Java DSL avec Spring (en fait leur cocktail préféré ». Cette bascule permanente permet certes d’aborder de manière exhaustive les deux manières de faire sur tous les sujets mais est aussi assez fatigante.

Lire la suite

Note de lecture : From Java to Ruby, par Bruce Tate

Note : 5 ; Un pamphlet pour la transition vers Ruby.

Ou comment l’un des chefs de file du monde Java prend le virage vers Ruby ! Ce livre est à la fois un argumentaire et une base de construction de stratégie de passage à Ruby. Un objectif limité en 8 chapitres seulement et 150 pages. Certes, l’enthousiasme de l’auteur éveille pour le moins l’intérêt et l’argumentaire est bien construit :

  • Un langage à typage dynamique, dont la productivité est dcuplée par rapport à Java.
  • En lieu et place d’une profusion de frameworks, un petit nombre de frameworks très en vue, dont le vaisseau amiral : le très remarqué Ruby on Rails.
  • Une réponse simple aux problèmes les plus fréquents, au lieu d’une solution complexe et généraliste.

Lire la suite

Note de lecture : Effective Java 3rd edt., par Joshua Bloch

Note : 7 ; Grosse prise de poids et hélas moins digeste, mais toujours une référence.

A chaque nouvelle édition, le titre phare du langage Java prends un peu plus d’embonpoint. L’édition précédente avouait 315 pages pour 78 items, nous voici avec 366 pour 90 items ! Il est vrai que cette nouvelle édition était nécessaire et attendue, essentiellement pour couvrir les nouveautés de Java 8, mais Java 9 n’est pas en reste bien que les modules ne soient pas abordés.

La pertinence du propos reste de mise. Mais il s’agit bien d’une édition augmentée et mise à jour, à l’exception de l’item 73 de la seconde édition qui a disparu. Mise à jour, elle l’est indubitablement. Chaque item et chaque exemple de code a été scrupuleusement revu afin de prendre en compte les évolutions de la librairie standard et du langage, aussi minimes soient-elles. Augmentée, elle l’est aussi des items touchant essentiellement les lambdas et les streams.

Le premier chapitre (en fait le second, car je n’ai pas compté l’introduction) n’a que peu changé, à part un nouvel item sur l’injection de dépendance (en fait le RAII) qui illustre un focus renforcé sur l’immutabilité des objets. Aucune modification au chapitre 3, hormis les quelques rafraichissements qui mettent les exemples au goût du jour.

Lire la suite

Note de lecture : Kotlin in Action, par Dmitry Jemerov & Svetlana Isakova

Note : 5 ; Fait le boulot.

Kotlin est un langage de la JVM que je classe dans la catégorie des « better Java », aux côtés de Ceylon (qui hélas n’a pas encore d’ouvrage). Le parti-pris du langage est celui d’une très bonne intégration avec Java (le langage), la manière dont chaque concept se traduit et peut être utilisé de ce côté est un fil rouge du livre. Ce n’est pas celui qui m’intéresse le plus, mais c’est une fonctionnalité forte (et limitante) du langage, donc… L’autre parti-pris est de s’adosser à une version déjà ancienne de la JVM : Java 6, mais ce dernier point n’a pas d’influence sur le texte.

Il y a fort peu à dire de ce texte, ni en bien ni en mal. Il est plutôt sans surprise. Le texte est raisonnablement clair et les extraits de code font le boulot. D’un autre côté, pas de « waouh effect ». Avec 310 pages sur 11 chapitres regroupés en deux parties, on reste également dans le standard, bien que dans la partie haute.

La première partie « introducing Kotlin » compte 6 chapitres et couvre 170 pages. Le premier d’entre-eux se contente d’une quinzaine d’entre-elles. Il a pour but de faire le tour des caractéristiques principales du langage et de son positionnement. C’est bien écrit, mais on n’est en réalité pas tellement avancé. Par contraste, le chapitre 2 « Kotlin basics » et ses un peu plus de 25 pages font un bon boulot pour couvrir les bases du langage : déclaration de classes et de méthodes, les propriétés (et leurs petites particularités) ainsi que des structures de contrôle : boucles, switches, énumérations, etc. On couvre bien les base et c’est bien écrit.

Lire la suite