Nous avons assisté cette année à l’édition belge du Devoxx. L’événement s’est déroulé à Anvers du 12 au 16 novembre (à partir du 14 pour les conférences traditionnelles). 
Le 
DevoxxBE est l’un des plus gros salons d’Europe sur, entre autres, l’écosystème Java. De ce fait, il constitue un bon indicateur de la santé et les tendances du langage de James Gosling. Nous nous concentrerons dans cet article sur le langage java autour de quelques conférences qui nous ont marqué.

 

Le salon

L’événement se déroule dans un cinéma, le son et l’image sont donc de qualité, les salles spacieuses et les sièges confortables. Les allées sont suffisamment larges pour pouvoir circuler sans trop d’encombre. Côté nourriture : salades, sandwichs, soupes, snacks et boissons sont mis à disposition en quantité et en libre-service. Le pays oblige, nous avons pu déguster quelques frites et une bière le premier soir ! Côté stands les plus gros étaient de la partie : Pivotal, Google, JetBrains, Redhat, Amazon, Lightbend et plein d’autres. Nous sommes revenus avec des goodies plein les poches, et même avec un raspberry pi gagné en complétant des tutorials GCP !

L’événement se déroule dans un cinéma, top confort !

La qualité des talks est bien au rendez-vous. Plusieurs formats sont proposés : les deep-dive lors des 2 premiers jours (3 heures par session) et les conférences pour les 3 derniers jours (1 heure) accompagnées de quickies (15 minutes) et de BOF : des sessions sous forme de discussions ouvertes et informelles.

Concernant l’organisation globale, rien à redire ! Nous aurions toutefois apprécié une application mobile un peu plus fluide et moins boguée, et une indication sur le niveau d’accessibilité des différentes conférences.

 

Keynote 

Nous sommes arrivés le mercredi 14, et c’est Stephan Janssen qui démarre la Keynote. Le Devoxx se porte bien, les places se vendent très rapidement, les propositions de talk se comptent à plusieurs milliers.

Le Devoxx est présent dans 7 pays, et une édition 2019 devrait se dérouler aux USA

Mark Reinhold a ensuite pris la parole, il nous présente la nouvelle release chain de java : une version mineure tous les 6 mois, une majeure « LTS » tous les 6 releases (soit tous les 3 ans). Une cadence donc plus élevée pour sortir de nouvelles fonctionnalités plus rapidement.

James Gosling, le papa de java, est ensuite monté sur le podium pour nous présenter Corretto, la distribution openJDK d’Amazon. Le géant met donc un pied dans le monde Java.
La distribution est prête à être utilisée en production, puisque utilisée en interne. Gratuite, elle bénéficie d’un support à long terme. Corretto est aussi compatible avec les standards Java SE, et dispose de binaires d’installation pour Amazon Linux, Mac OS et Windows. Corretto ne supporte que la Hotspot JVM, et ne se base que sur l’OpenJDK.

A noter enfin que si la JDK d’Oracle devient payante, Corretto n’est pas la seule solution gratuite. En effet il existe une alternative communautaire : l’AdoptOpenJDK. Cette dernière dispose aussi d’un support à long terme pour les LTS (8 , 11 et la future 17), d’une importante base de tests, et d’une compatibilité avec l’OpenJ9 JVM. Si vous aimez ce type d’initiative, je ne saurais que vous la conseiller ! N’hésitez donc pas à contribuer à ce projet en donnant un peu de votre temps ou de votre argent.

Liens des présentations :
Welcome keynote by Stephan Janssen

Java in 2018: Change is the Only Constant Keynote by Mark Reinhold
Amazon Keynote by James Gosling

 

SPEARHEADING THE FUTURE OF PROGRAMMING par Venkat Subramaniam

Venkat Subramaniam est intervenu pour la dernière partie de la keynote,  afin de nous partager sa vision de la programmation pour les années futures.

Le contexte a beaucoup changé durant ces 15 dernières années : nous parlons de big data, de social media feeds, de recevoir les données d’un avion en plein vol ou encore d’observer des atomes en mouvement. Ces nouvelles problématiques demandent une certaine adaptation dans notre manière de développer, mais aussi de nouvelles technologies pour être adressées. Malheureusement force est de constater que les habitudes sont difficiles à changer : il nous a fallu environ 23 ans pour adopter OOP, et nous commençons seulement à utiliser FP, qui lui est vieux de 80 ans ! Venkat cherche ici à nous sensibiliser sur ce point.

Les nouvelles problématiques auxquelles nous sommes confrontés ont toutefois quelques éléments de réponse et notamment NoSQL, MapReduce ou Reactive.

Au travers de ces solutions, Venkat trouve le principe de continuation particulièrement intéressant. Dans notre code cela est utilisé par les coroutines (en Kotlin notamment), et si nous allons plus loin, cela est rendu possible avec les closures (en javascript notamment): une fonction qui transporte un état avec elle.

Save execution state and return to that point later in time

Les continuations nous permettent de garder une cohérence dans l’exécution du code,  mais aussi de nous rapprocher du modèle de communication humain :  nous communiquons en nous souvenant de notre interlocuteur mais aussi de nos précédents échanges.
N’est-ce pas dans cette direction que nous allons ? Venkat nous rappelle « l’ancien web » : quand le serveur renvoyait, de manière stateless, de l’html au client.

Si nous arrivons à écrire du code concurrent avec une structure séquentielle (nous penserons aux streams à partir de java 8), Venkat pense que le gain sera encore plus conséquent à l’avenir si l’on écrit notre code asynchrone avec une structure synchrone.

Un autre point qui enthousiasme Venkat est l’amélioration de l’expressivité du code. Les compilateurs sont plus intelligents, de nouvelles features, comme la data class en Kotlin, permettent de réduire le boilerplate. Enfin la composition de fonction, le programmation déclarative, nous permet de rendre notre code beaucoup plus lisible. Ces améliorations nous permettent de nous concentrer davantage sur notre code et ainsi en améliorer la qualité.

Venkat insiste particulièrement sur le fait qu’il est essentiel de ne pas masquer les différences de sémantiques à l’utilisateur lors de l’ajout de nouvelles fonctionnalités. Nous penserons aux séquences en Kotlin et aux streams en Java qui nous permettent d’exécuter les calculs eagerly ou lazilyDe cette façon, un rapport de confiance est gardé avec le programmeur, et bon nombre d’erreurs peuvent ainsi être évitées.

Enfin n’oublions pas de tester et d’apprendre de nouveaux langages, chacun a ses propres forces et est donc riche d’enseignement. Venkat conclut sur une expérience qui s’est déroulée à Chicago, cette dernière montre que les enfants polyglottes sont plus à même de changer leur point de vue pour mieux répondre à une question !

Lien de la présentation :
Spearheading the future of programming Keynote by Venkat Subramaniam

 

JAVA, TODAY AND TOMORROW par Mark Reinhold

Mark Reinhold nous propose durant cette présentation un tour d’horizon des projets java.
Chaque point est illustré avec du code, des graphs et des exemples qui fonctionnent : c’est très plaisant et excitant à voir ! 

Amber :
L’ambition ici est de réduire le boilerplate de java, qui est d’autant plus pénible à l’heure des micro-services data-drivenOn retrouve donc ici une série de features comme le Local variable Type Inference – var, le nouveau switch et la record class présentée ci-dessous :

record Point(double x, double y);

 inclut directement :

Point(double x, double y) {
    this.x = x;
    this.y = y;
}

double x() { return x; }

double y() { return y; }

double equals(Object ob) {
    if (not (ob instanceof Point))
        return false;
    Point that = (Point)ob;
    return (this.x == that.x) && (this.y == that.y);
}

double hashCode() {
    return x * 31 + y;
}

double toString() {
    return "Point(" + x + ", " + y + ")";
}

Ça me fait penser à un autre langage très populaire du moment, pas vous ? ;-

Loom :
Il s’agit ici de gérer les threads non plus au niveau de l’OS, mais de la JVM : les fibersL’overhead est ainsi réduit de manière conséquente. Le projet prévoit aussi des continuations (ou encore coroutines) appuyé par ces fibers. Le code bloquant ne serait donc plus un problème.
Telle est l’ambition de Loom. Personnellement je ne pense pas le voir sortir avant le JDK 17 (prochaine LTS).

Panama :
Le but ici est de connecter la JVM avec des apis étrangères (non-java). Tout particulièrement les interfaces les plus utilisées en C.
La démonstration de Mark Reinhold est la suivante :
– Extraire le fameux unistd.h :

jextract unistd.h

Il obtient ainsi un fichier unistd.class

– Tester getpid() :

Libraries.bind(MethodHandles.lookup(), unistd.class).getpid()

En retour : le pid de l’application Java

Valhalla :
L’idée du projet est de rendre le langage Java plus performant pour le calcul matriciel, mais aussi pour le data engineering. À l’heure actuelle tous les objets en Java ont une identité (ce qui implique l’usage de pointeurs), impactant le cache et les ressources de traitement. L’idée est donc d’implémenter le value type, qui sera un type consacré uniquement aux données et qui ne disposera pas d’identité.

public value class Complex

Pour résumer, de nombreux projets très intéressants qui commencent à se concrétiser !

Lien de la présentation :
Java, Today and Tomorrow by Mark Reinhold

 

OOP VS/AND FP par Mario Fusco

Lors de ce salon, le Functionnal Programming fut l’un des sujets les plus mis en avant.
Mario Fusco débute son talk en nous rappelant notre fâcheuse tendance à scinder les choses. En ingénierie logicielle, nous penserons forcément à SQL/Non-SQL ou Monotith/Micro-Services. Nous sommes naturellement tentés d’utiliser exclusivement les dernières technologies, les dernières méthodologies et souvent à tort. Et évidemment OOP (Object Oriented Programming)/FP n’échappe pas à la règle, comme nous pouvons le constater de nos jours.

Mario nous expose donc en quoi cette dichotomie est inexacte.

« Actually I made up the term « object-oriented », and I can tell you I did not have C++ in mind » – Alan Kay (un des pères d’OOP)

Cette citation illustre une mal-compréhension : quand nous parlons de c++ ou encore de java, il est plus approprié de parler de Class Oriented Programming, qui est une des implémentations d’OOP.

Pour rappel, le principe de ce paradigme est de travailler avec des objets ayant chacun un état privé et communiquant en s’échangeant de petits messages.
En y pensant, c’est exactement ce que fait le modèle d’acteurs que l’on retrouve avec Erlang ou encore Scala (Akka).

Mario nous propose donc un tour d’horizon des différents points de divergence entre les deux paradigmes.

Polymorphism – Functional Decomposition
C’est ici le principal avantage d’OOP : le polymorphisme (rendu possible par héritage et/ou association) nous permet une certaine extensibilité. Du côté FP, il faudra se contenter de if(expr instanceof type) pour permettre la composition.

Mutable – Immutable
L’immutabilité est le grand point fort de FP. Cela nous permet de travailler de manière sûre avec plusieurs threads, de pouvoir assurer la consistance et l’exactitude des valeurs. Notons tout de même que cela à un prix : supprimer et recréer nos objets coûte plus chers que de simplement les modifier.

Exceptions – Optional / Validation
En java, parseInt(String str) à la possibilité de jeter une NumberFormatException, mais qu’y a-t-il d’exceptionnel au fait de ne pas pouvoir parser une string en integer ? Mario souligne ici notre tendance à abuser des exceptions, qui a pour effet de limiter la mémoïsation : pouvoir mettre en cache le résultat d’une fonction. Il serait préférable de retourner un tuple d’une valeur et d’une exception que nous traiterions plus tard.

Imperative – Declarative
Au travers d’un exemple, Mario nous montre que programmer de manière déclarative, nous permet de rendre le code plus compact, de séparer de manière plus claire les problèmes, et ainsi rendre le code plus lisible. Cependant, cela n’est pas systématiquement vrai, et il peut être très complexe de faire évoluer un code déclaratif.

Threads – (Completable)Future
Nous connaissons les problèmes engendrés par un état partagé par plusieurs threads. Les futures nous permettent d’y remédier, cependant gare à ne pas tomber dans le callback hell.

Statements – Expressions
Favorisons les expressions si le langage nous le permet !

Iteration – Recursion
L’ itération est plus lisible et plus rapide, mais elle implique aussi la mutation d’un état.

Pour Mario, tout comme l’a affirmé Bryan Goetz dans sa présentation FP vs OOP: Choose Two, il est intéressant d’utiliser OOP pour les périmètres « large » (architecture et stateful), et FP dans les cas plus « fin » (les calculs).

Ou inversement ? Il pourrait être intéressant d’orchestrer des composants de manière fonctionnelle par exemple. Le tout est de rester le plus pragmatique possible, les deux paradigmes sont le plus souvent orthogonaux et un choix (voir une combinaison) pertinent peut être fait pour chaque situation.

En définitive, nous vous invitons à visionner la vidéo de cette conférence : chaque point y est présenté avec du code et des cas concrets.

There is no silver bullet

Lien de la présentation :
OOP v̶s̶ and FP by Mario Fusco

 

Conclusion

Nous avons ici couvert quelques conférences majeures de ce Devoxx concernant les news java, la tournure que prend la programmation et notamment FP. Nous relèverons les principales tendances suivantes lors de ce salon, n’hésitez pas à y jeter un œil en complément de cet article  :
– Reactive programming
– Kotlin
– Kubernetes
– Micro-services
– GraalVM 
– Functionnal programming

Enfin nous vous recommandons la lecture de l’article « Retour sur le Spring One Tour » pour plus d’informations sur l’univers Spring, framework qui nous apporte chaque année son lot de nouveautés !

 

Liens utiles