Il n’était à l’origine pas prévu que j’assiste à ScalaIO.
Scala est un langage que je pratique régulièrement depuis trois ans et quasi quotidiennement depuis deux ans, sur un gros projet personnel qui devrait enfin voir le jour d’ici peu. C’est est un langage que j’apprécie beaucoup, bien plus que Java. Il m’a fait mûrir et devenir un meilleur développeur, en m’initiant notamment à la programmation fonctionnelle. Je suis son actualité et je cotoie sa communauté, en me rendant notamment au user group parisien. Mais Scala est un langage que je ne pratique pas dans le cadre de mon travail salarié classique, et de moins en moins sur mes side projects autres dont le fameux gros projet évoqué plus haut. Pour être tout à fait honnête, le vrai langage qui me botte actuellement et qui me donne envie de coder le soir en rentrant chez moi même après une longue journée de développement, c’est Clojure. Avec Clojure, je n’ai plus du tout la sensation du faire du développement classique et je sens des zones jusqu’ici inexploitées de mon cerveau s’activer. Au contraire, Scala ne m’est jamais apparu plus que comme une extension, certes riche, de Java. J’ai lu des livres, vu des conférences, mais sans jamais me détacher de cette image d’un super-java, très adapté pour construire des applis ultra robustes, mais moins pour s’offrir une petite cure de fraîcheur.
Et puis début octobre, lors du Clojure User Group parisien, que je recommande chaudement, j’ai gagné une place pour la conférence. C’était l’occasion rêvée pour vivre au rythme de Scala pendant deux jours et confirmer, ou infirmer, mon opinion vis-à-vis du langage. Je m’y suis rendu comme se rend dans un monastère un chrétien doutant de sa foi.

Comme dans toutes les bonnes conférences, les choix à faire côté planning sont cornéliens. J’ai choisi de rester généraliste et de voir un peu de tout :

• Scala « core », Scala avancé, bonnes pratiques de développement
• Framework et tools (Akka, Play, etc.)
• Big Data (Spark, Scalding, etc.)

Entrons maintenant dans le vif du sujet avec les talks vus !

Distributed in Space and Time, par Roland Kuhn (Typesafe)
La première journée commence fort avec une Keynote par le lead developer d’Akka. Bonne conférence, accessible, peut-être un peu superficielle mais on ne demande pas un sujet ardu pour une Keynote pour débuter une conférence un matin à 9h. On demande à ce qu’elle montre une direction, qu’elle fixe un cap, et c’était réussi.

Large Road-Network analysis with GraphX, par Rand Hindi et Andy Petrella
GraphX est un framework de Scala permettant de gérer des graphes. Dans une première partie, Andy Petrella a rappelé les bases mathématiques et exposé GraphX. Dans une seconde, Rand Hindi a montré un cas d’utilisation, avec l’analyse de données topologiques d’Open Street Maps pour en sortir des prédictions concernant le risque d’accident sur chaque tronçon de route. J’ai trouvé les deux parties très intéressantes, claires et dynamiques, bien qu’un peu frustrantes. Elles auraient toutes les deux mérité de durer deux fois plus longtemps. Je n’aurais pas dit non à un peu de rab !

Stream all the things ! - life at the end of the firehose, par Yann Schwartz et Sofian Djamaa
Ou comment Criteo a implémenté une architecture hybride batch (avec je ne sais plus quoi, Scalding ?) / streaming (avec Storm) pour traiter ses énormes volumes de données, en se basant notamment sur Summingbird et Algebird (développés par Twitter) pour combiner les deux. Avec aussi du Clojure caché dans un coin grâce à Riemann, ça m’a fait plaisir. J’ai trouvé que c’était une excellente présentation, claire et complète, précise et pointue tout en étant très accessible, pleine de franchise aussi, bref, un retour d’expérience modèle.

Building a Distributed Data Ingestion System with Rabbit MQ, par Alvaro Videla
Je voulais plutôt assister au talk sur l’event-sourcing par Jérémie Chassaing, mais je l’ai raté pour cause d’affluence. Caramba, encore raté ! pourrais-je dire car j’avais déjà raté ses présentations organisées chez Arolla il y a quelques mois de cela. J’espère qu’il va continuer à en faire. Je me suis donc rabattu sur cette présentation de RabbitMQ. Présentation agréable et rythmée mais qui ne m’a pas retourné, j’ai trouvé que c’était un peu trop terre-à-terre et que ça ressemblait trop à un simple listing des meilleures features de RabbitMQ.

Let Curry-Howard your code for me, par Alexandre Bertails
Pas la plus simple des conférences à suivre lorsqu’on est en pleine digestion et tenté par la sieste, mais passionnante pourvu qu’on se donne la peine d’être bien attentif. Pour faire simple (si j’ai bien tout saisi), les types sont des propositions, tandis que les programmes sont des preuves. C’est ce qu’on appelle l’isomorphisme de Curry-Howard. Alexandre Bertails l’a présenté à l’aide de Scala. C’est typiquement le genre de talks que je suis content de trouver dans une conférence comme celle-ci. Je reviens là-dessus plus tard.

PureScript, par Bodil Stokke
PureScript est un langage à la syntaxe très proche de Haskell et compilant vers Javascript. N’étant pas franchement un spécialiste de Javascript, les alternatives comme celui-ci ou ClojureScript m’intéressent beaucoup. Bodil Stokke a développé devant nous un jeu de plateforme où on incarne le poney rose Pimkie et où on doit attraper des dogecoins. Que dire si ce n’est wow, such power. Une présentation assez barrée qui a détonné parmi toutes les autres. J’aurais juste aimé en savoir un peu plus sur les dessous du langage, que la surface soit un peu plus grattée, mais c’était bien.

Lightning fast cluster computing with Cassandra and Spark, par Piotr Kolaczkowski
Piotr Kolaczkowski, ingénieur chez DataStax, nous a fait un retour d’expérience sur le développement de spark-cassandra-connector, un framework qui comme son nom l’indique connecte Spark et Cassandra. Passée une rapide introduction de Spark puis de Cassandra, on est entré dans le vif du sujet avec un retour complet sur le développement de ce framework. Bon retour d’expérience, précis et complet, assez péchu.

Type-Level Computations in Scala, par Stefan Zeiger
Stefan Zeiger a exploré les possibilités offertes par le système de types, permettant d’intervenir directement lors de la compilation et donc de faire en sorte que le compilateur travaille pour soi. Certains contrôles que l’on pourrait faire au runtime, avec du pattern matching par exemple, peuvent donc être faits plutôt à la compilation et donc offrir de meilleures performances. Un talk ardu demandant une certaine concentration mais très gratifiant à l’arrivée.

There’s a prolog in your Scala !, par George Leontiev
Poursuite de notre chemin dans les méandres du type-level avec un focus sur les aspects de programmation logique qui se nichent au coeur de ce système. La programmation logique est quelque chose que j’ai découvert à l’école, avec Prolog, et qui ne m’avait alors pas vraiment enthousiasmé. Je l’ai redécouverte il y a peu grâce à Clojure et sa bibliothèque core.logic, passionnante à utiliser et idéale pour redécouvrir les fondamentaux de ce paradigme. J’étais donc assez impatient d’assister à ce talk, qui ne m’a pas déçu. Bonne introduction à la programmation logique, bon équilibre en la théorie et la pratique avec une belle session de live-coding, c’était riche mais accessible. Là encore, c’est toute une facette de Scala qui m’était invisible qui m’est apparue.

Prismic.io: Two years journey of distributed system development with Scala, Play and co, par Sadek Drobi
Prismic.io est un CMS next-gen développé par Zengularity (à qui on doit déjà Play!), que j’avais suivi à sa sortie mais que j’avais ensuite perdu de vue. J’avais trouvé l’UI très réussie mais, n’étant pas utilisateur de CMS, cela ne m’avait pas intéressé plus que cela. Dans ce talk haut en couleurs, Sadek Drobi est revenu sur les nouveautés offertes par Prismic, mais surtout sur son architecture novatrice pleines choses que je n’avais jamais vu ailleurs. J’ai trouvé ça très inspirant, très motivant pour aller inventer de nouvelles approches visant à régler des problèmes pourtant vieux comme le monde.

From research to production with Scalding, Algebird and Spark, par Christopher Severs (eBay)
Ce talk a fait écho à celui de Yann Schwartz et Sofian Djamaa qui évoquait un sujet proche et qui prenait aussi la forme d’un retour d’expérience. Là encore, j’ai apprécié l’introduction au problème rencontré par eBay, la franchise du speaker, le retour précis sur toutes les technologies utilisées.

TDD, comme dans Type Driven Development, par Clément Delafargue
Un talk bluffant, vraiment. C’est probablement le talk le plus réussi de tous ceux que j’ai vus durant ces deux jours. Le sujet est pourtant assez restreint et n’a pas l’air d’envoyer du rêve à première vue. Le talk pouvait en effet ressembler de loin à un cours assez modeste sur une énième façon d’écrire des tests … Or il m’a permis en quelque sorte de digérer les trois talks théoriques de la veille, « Let Curry-Howard your code for me », « Type-Level Computations in Scala », et « There’s a prolog in your Scala ! », en revenant sur les possibilités infinies offertes par le système de types mais avec une approche plus pratique, plus hacker. J’ai trouvé ce cours très intelligent pour son accessibilité et sa façon d’initier en douceur l’auditoire à des approches complexes. La progression du talk a été exemplaire, Clément Delafargue étant allé jusqu’à prendre le temps de passer quelques minutes au départ sur des fondamentaux qui devaient pourtant être maitrisés par toute la salle. J’ai beaucoup aimé la volonté de démystifier scalaz et ce dès les premières minutes, avec la citation de types élémentaires, simples à utiliser et très pratiques, comme « Validation » ou « NonEmptyList ». Un modèle de talk pédagogique, je ne dirais pas non à quelques autres cours (car c’est un talk qui peut vraiment être qualifié de cours) comme celui-ci.

A tale of futures, actors and pipes: using Akka for large-scale data migration, par Manuel Bernhardt
Déjà, un talk qui se base sur des références et des citations sorties de « Retour vers le futur » ou « Breakfast at Tiffany’s » ne pouvait pas me déplaire. Le sujet était assez original, avec la présentation du développement d’un système écrit en Akka chargé de migrer en un week-end un volume considérable de données. Rien de retournant dans ce talk mais beaucoup d’efficacité et de passion, j’ai beaucoup aimé.

Comme vous l’aurez constaté, j’aurai vu beaucoup de belles choses durant ces deux jours. Il y a bien quelques talks qui m’ont plus ou moins déçus, souvent pour leur superficialité… et pour l’ennui qu’ils ont causé, mais j’ai choisi de ne pas les évoquer ici.

Plus généralement, j’ai trouvé le programme global de la conférence très équilibré. L’univers Scala a beau être encore tout petit en comparaison d’un mammouth comme Java, il déborde déjà de toutes parts, est présent sur tous les fronts, et j’ai trouvé que c’était bien rendu dans les talks choisis. Je n’ai jamais eu l’impression que ça se répétait ou que ça radotait.
J’ai apprécié tous les talks autour de Spark, Summingbird et autres technos Big Data, certainement parce que c’est un sujet qui touche directement mon job quotidien de développeur, mais comme dit dans l’introduction de cet article, j’attendais de cette conférence qu’elle me donne des raisons de me repencher sur Scala, pas l’écosystème, mais le langage. Je voulais qu’on me donne des raisons gratuites, purement intellectuelles, d’écrire en Scala, au delà des raisons pratiques offertes par tout l’attirail Play, Akka, Spark, etc.

Eh bien, merci, j’ai été largement récompensé de côté là, notamment grâce aux talks « Let Curry-Howard your code for me », « Type-Level Computations in Scala », « There’s a prolog in your Scala ! » et « TDD, comme dans Type Driven Development ». Ces talks m’ont donné envie de replonger plus sérieusement dans scalaz ou d’explorer plus en profondeur le système de types, en écrivant les mêmes tests que ceux présentés par Clément Delafargue par exemple. Cette approche théorique franche est quelque chose que je ne retrouve quasiment jamais dans des meetups ou user groups classiques, et même dans des grosses conférences. Ca m’avait manqué à Devoxx par exemple. Peut-être parce qu’il n’y a plus rien à dire sur Java en tant que langage ? Peut-être parce que Java n’est plus rien sans sa particule JEE ? Toujours est-il que je suis content d’avoir vu ça pour Scala.

Bien sûr, c’est le type de talks qui va conforter les grincheux qui ne voient dans Scala qu’un langage élitiste et volontairement compliqué, mais pour les autres, c’est de la bonne nourriture cérébrale comme on en voit peu. Surtout, que cela soit basé sur Scala est finalement assez secondaire. Haskell revenait par exemple systématiquement dans ces talks. Ce sont des notions informatiques théoriques centrales qui étaient au coeur du sujet, pas le langage en lui-même, d’où l’intérêt qu’ils peuvent procurer à tous les développeurs qui cherchent à gratter sous leur code écrit quotidiennement… y compris ceux qui comme moi sont en ce moment plutôt concentrés sur un langage dynamique (bouh !) comme Clojure.

Bref, encore un grand merci pour la place offerte, et qui sait, peut-être à l’année prochaine !