Retour sur Devoxx UK 2015

Mark-FINAL-Comp-v3-low
Organisée par des développeurs et pour des développeurs, Devoxx est une conférence sur Java, la JVM et ses langages, ainsi que sur les technos web et mobile. L’édition de Londres s’est déroulée du 17 au 19 Juin 2015 et a rassemblé environ 1100 personnes. Voici un compte-rendu des présentations qui m’ont le plus marqué.

Jour 1 – Nuts and Bolts of WebSocket – par Arun Gupta

Cette session de 3h30 avec Arun Gupta (expert en microservices et auteur de nombreux articles) visait à donner une présentation globale des WebSocket. Après une rapide présentation d’HTML et de ses avantages et défauts (client-driven, half duplex, verbeux, nouvelle connexion TCP/IP à chaque requête, etc.), le speaker nous a présenté les WebSockets et ses avantages (Connexion bidirectionnelle, full duplex, protocole léger, une seule connexion TCP qui reste ouverte, etc.).

Arun Gupta a montré des exemples de code (Java et JavaScript) pour les utiliser, et abordé les différents problèmes que l’on peut rencontrer avec (DNS, Firewall…) ainsi que les problématiques de load balancing et de scalabilité (seulement verticale). S’en est suivi une présentation des encodeurs/décodeurs de message pour la performance et quelques benchmarks très précis afin de comparer les WebSockets avec du REST/HTML.

Pour finir, il nous a rapidement présenté « Atmosphere », un framework permettant de détecter si le client n’est pas compatible WebSocket (lié à un browser trop ancien) et donc de switcher automatiquement en long polling (html).

J’ai beaucoup apprécié cette présentation qui a permis de faire un tour d’horizon complet sur cette technologie, en abordant une multitude d’aspects et de manière très synthétique.

Jour 1 – From requirements to Deployment : Implementing microservice in Java using BDD & TDD – par John Smart

Cette session de 3h30 visait à développer des micro services en se basant sur du BDD (Behaviour Driven Development). Le speaker a commencé par rappeler les caractéristiques des microservices (une seule responsabilité, faiblement couplé, déployable indépendamment), ainsi que la pyramide de test des applications monolithiques (tests unitaires (beaucoup), tests d’intégration (moins) et les tests du système entier (peu)).

Malheureusement cette pyramide ne fonctionne pas avec les microservices… En effet, les raisons pour lesquelles nous testons est que nous souhaitons nous assurer que nous délivrons des fonctionnalités à valeur ajoutée et qui soient bien documentées. Ce que nous permet le BDD à condition d’adopter une autre pyramide de tests (Des specs techniques rapidement exécutables (beaucoup), des specs techniques exécutables plus lentes (moins) et quelques specs exécutables orienté business).

Ainsi, en utilisant différents outils nous avons passé 1h30 à développer des microservices en se basant sur du BDD. Voici la liste des outils, que je vous invite à regarder dans le détail :

  • MounteBank
  • Pacto
  • Cucumber
  • Spring IO
  • Rest-assured
  • Spock
  • Swagger & RAML (docs from annotations)

Jour 2 – The Extraordinary Team of Developers – by Trisha Gee and Daniel Bryant

Une keynote assurément motivante, qui a commencé de façon originale avec l’arrivée d’un groupe de samba pour chauffer la salle, applaudissements et chants à l’appui ! De fait, l’auditoire était bien réveillé et tout ouïe pour la keynote, où les speakers ont mis à mal le mythe du développeur ninja/héros/rockstar. Aujourd’hui, ce qui compte c’est l’équipe et le collectif. Alors, quelles sont les différentes facettes d’une équipe saine, qui s’entraide, progresse et développe un produit à forte valeur ajoutée ? A travers l’évocation de différentes anecdotes et d’ouvrages qui les ont guidés, Trisha Gee et Daniel Bryant ont abordé les différents moyens mis en oeuvre pour amener une équipe au niveau d’efficacité désiré.

Jour 2 – Java 9 – Make way for modules – Mark Reinhold

Dans cette présentation, Mark Reinhold, responsable de l’architecture de la plateforme Java, a présenté la plus grande nouveauté de Java 9: les modules (nom de code Jigsaw).

Cette technologie de rupture vise à découper le JRE en petits modules afin que nos programmes ne soient dépendants que du minimum. Ce qui permettra de gagner de la place sur des plateformes embarquées (ex: RaspberyPi) mais aussi dans le cloud. En effet, plus on installe le JRE dans son ensemble plus on perd de la place qui pourrait être préservée en n’installant que les modules nécessaires (par exemple sans la couche graphique pour les serveurs).

L’autre intérêt est de limiter les impacts sur les failles de sécurité provenant de code non utilisé et des classes internes (sun.* et *.internal.*) mais aussi de supprimer le Classpath et tous les problèmes qui en découlent (librairies en doubles et/ou manquante).

Mark Reinhold a ensuite montré les différentes parties constituant le JRE ainsi que leurs dépendances en Java 8… Et on peut dire que c’est vraiment brouillon: il y a des dépendances absolument partout. De là, il est passé au nouveau schéma de dépendances en Java 9, et même si ça va améliorer les choses, il restera pas mal de dépendances. Autre nouveauté, un nouveau format de fichier va remplacer les jars et le vieux « rt.jar » disparaîtra.

Enfin le speaker nous as présenté jdeps, un outil en ligne de commande (disponible dans le jdk8) qui permet de visualiser les dépendances entre packages/jar afin d’avoir une idée de ce qu’il va se passer avec Java 9 et d’anticiper les dépendances de ses propres développements.

Jour 2 – Let’s go to the rapids: Java 8 Stream performance – Maurice Naftalin

Maurice Naftalin, auteur de « Mastering lambdas: Java programming in a multicore world » et de la FAQ sur les lambdas, a présenté ici les streams de Java 8 du point de vue de la performance. Après avoir rappelé les difficultés à établir un bon benchmark, il a abordé les outils à utiliser (JMH et Caliper) et la question de la nécessité de mesurer les bons scénarios (sinon ça ne sert à rien). Enfin, il nous démontré les Collectors pouvaient être chers, et combien les parallel streams pouvaient être inefficaces (à cause du ForkJoinPool partagé par tous les parallels streams).

Il a conclu sur une remarque que j’ai trouvé très pertinente: les performances ne sont pas toujours importantes en comparaison avec du code clair et précis. Il préconise de toujours optimiser ce qui est nécessaire mais pas systématiquement.

Jour 2 (Quickie)- 5 Reasons why developers should pay attention to robotics – Nicolas Rigaud

Ce quickie de 20 minutes était intéressant car il faisait un tour d’horizon de la robotique d’aujourd’hui et nous montrait à quel point la robotique pourrait devenir la prochaine grande innovation. Ce qu’il faut en retenir :

  • Des technologies de plus en plus matures (composants moins chers, plus petits et plus performants)
  • Des environnements de développement de plus en plus accessibles (Java, JavaScript, Python, …)
  • Un intérêt croissant sur le marché (des banques et restaurants en utilisent déjà en Chine)
  • Un business en cours de développement (AppStore, AppAnalytics)
  • La robotique, c’est fun !

Jour 2 – Refactoring your JavaEE applications using microservices – by Arun Gupta

Après avoir rappelé les avantages et inconvénients entre les applications monolithiques et microservices, Arun Gupta a présenté les différents concepts à prendre en compte (load balancer, cache, BDD) et plusieurs patterns pouvant être utilisés pour établir ce genre d’architecture. Une présentation intéressante mais qui reposait surtout sur un article de l’auteur que j’avais déjà lu. Je vous recommande vivement sa lecture.

Jour 2 – Comparing different concurrency models on the JVM – by Mario Fusco

De loin ma présentation préférée. Malgré la densité d’informations, Mario Fusco a réussi à synthétiser et expliquer tous ces concepts d’une très bonne façon. Durant la conférence, il a listé tous les moyens de faire de la programmation parallèle en Java (Threads et locks, Threads et queues, programmation fonctionnelle, Actor, Software transactional memory (STM), Futures, programmation réactive) et pour chacune de ces méthodes, il a expliqué chacun des avantages et inconvénients que l’on rencontre en les utilisant.

Ce que j’ai le plus apprécié :

  • Utiliser des threads et des locks c’est comme programmer en assembleur. Faire de la programmation concurrente, c’est faire de la programmation. Et qui a envie de faire de la programmation en assembleur?
  • La meilleure façon d’écrire une librairie concurrente c’est de ne pas laisser l’utilisateur penser à la parallélisation.
  • En programmation parallèle, il n’y a pas de solutions miracles. Chacune a ses avantages et ses inconvénients.

Jour 2 – Java 8 in anger – by Trisha Gee

Durant cette session de live coding, Trisha Gee a montré comment développer un dashboard (en JavaFX) qui récupère des tweets depuis des webservices (aussi développé durant la session), le tout en utilisant la puissance de Java 8. On se rend compte que finalement il n’y a pas forcément besoin d’utiliser le dernier frameworks à la mode pour développer des web services. Java 8 suffit et est très efficace. On peut trouver les sources sur github.

Jour 3 – 50 minutes to develop a full JavaEE application with forge – by Antonio Goncalves

Une autre session live coding, animée par Antonio Goncalves (un des organisateurs de Devoxx France et membre du Paris JUG), durant laquelle il a présenté l’utilisation de Forge (et de sa CLI) pour simplifier l’écriture d’applications JavaEE. Aujourd’hui, les applications JavaEE sont vieilles et particulièrement compliquées (la spec fait environ 800 pages) ce qui rend le développement difficile. D’un autre côté, Forge, grâce à son outil en ligne de commande, permet de simplifier la création des classes en générant du code. N’étant pas un spécialiste des applications JavaEE, je n’ai pas perçu toute la force de l’outil mais c’était plutôt impressionnant de voir à quels point les classes étaient générées, mises à jour et déployées sur Forge.

Jour 3 – Design Patterns in the 21st Century

Cette session visait à montrer que les design patterns du GangOfFour vont certainement évoluer (voire disparaître) avec l’arrivée de la programmation fonctionnelle. Quelques exemples :

  • AbstractFactory -> facilement remplaçable grâce aux lambdas
  • L’adapter -> aussi facilement remplaçable grâce à la simplicité des conversions en Java 8 (exception faite des interfaces à plus d’une méthode)
  • Chain of responsability -> très facile en utilisant la composition de méthodes/fonctions avec une programmation fluent (ex: object.then(param1).then(param2).then(param3))

Jour 3 – The bootiful application – by Josh Long

Cette session de live coding animée par un excellent speaker de Pivotal (qui édite Spring) avait pour objectif de montrer comment développer une application spring boot. N’étant pas un expert des solutions Spring/Pivotal, j’avoue avoir été très vite perdu tant le speaker allait vite dans ses développements.

Jour 3 – Scaling wix.com with microservices architectures and multi-cloud platforms – Aviran Mordo

Cette session était consacrée à un retour d’expérience sur la mise en place du site Wix.com. Le site est passé d’une application monolithique à une architecture en micro services pouvant gérer 66 millions d’utilisateurs et 2Pb de données en quelques années. Au cours de la session, le speaker nous as présenté les problématiques rencontrées et les choix effectués afin de les résoudre : comment découper l’architecture, où optimiser la performance, comment découper les bases de données et leurs caches. Une session très vraiment dense en informations.

Jour 3 – Combining R with Java for data analysis – by Ryan Cuprak and Elsa Cuprak

Ayant beaucoup entendu parler de ce langage, je voulais voir de quoi il en retournait. Ryan et Elsa Cuprak ont présenté le domaine d’utilisation de ce langage (comparable à MatLab): résoudre des problèmes statistiques et afficher les résultats. Après avoir détaillé les principales instructions et structures de données utilisées, les speakers ont montré comment appeler du Java depuis R, et inversement appeler du R depuis Java ainsi que les problèmes techniques qui peuvent arriver (deadlock, crash, …). C’était une introduction très intéressante et vraiment accessible pour un développeur java, non statisticien.

Jour 3 – Top 10 Real-Life WebSocket use cases and experiences – by Rich Cullen

Durant cette session, Rich Cullen a rappelé les principes des WebSockets (par rapport au HTML) avant de passer à de nombreux exemples d’utilisations :

  • Application de trading
  • Jeux sur smartphone
  • Voiture, drone téléguidés par smartphone
  • Automobile (taille réelle!) pilotée par smartphone en passant par la 3G

Finalement, l’édition 2015 de Devoxx UK s’est terminée…heureusement, car je commençais à fatiguer ! Bien qu’étant légèrement plus petite que son homologue parisienne, il faut reconnaître que Devoxx UK 2015 était une réussite : organisation au top, présentations enrichissantes et rencontres passionnantes. Vivement l’année prochaine !

Crédit photos : Mark Hazell

Commentaires :

A lire également sur le sujet :