Premier post en français sur ce blog pour un rapide retour sur le Devfest Toulouse édition 2017 ayant eu lieu le 28 septembre. Cette deuxième édition a été très bien menée par une équipe de bénévoles au top, pour un résultat de grande qualité. Un grand merci à eux pour le travail fourni !
La conférence se déroulait avec 4 talks en parallèle avec une keynote de début et une keynote de fin. J'avais opté pour l'agenda suivant :

• keynote d'ouverture : Le développeur Full Stack est mort, Vive le développeur universel
• Demain j'arrête le café, je me mets au crabe
• L'UX a sauvé mon DevOps
• Balade au pays de Let's encrypt
• Des portes logiques pneumatiques en bois
• Plus loin avec Kotlin !
• BATTLESTAR GALACTICA: Saison 5 - Les Cylons passent dans le cloud avec Vert.x
• Functional Programming Explained to my grandma
• Quand nous avons emmené notre web app chez les Bisounours
• Keynote de clôture : Apéro fonctionnel

Revenons en détail sur cette journée et les différentes présentations.

Keynote d'ouverture

Assurée par Thomas Gx de Commit Strip, je m'attendais à une réflexion drôle sur le développeur fullstack, un peu sur le ton des célèbres strips. Au lieu de cela, un talk très sérieux, au sujet de la place du développeur dans la révolution industrielle (la 3ème ou la 4ème) en cours. Son propos était de nous inviter à imaginer l'image du développeur d'aujourd'hui, tel que le verront les futures générations, un peu à la lumière de ce que l'on fait quand on pense à l'époque de la première révolution industrielle.

Mon (humble) avis

Autant le dire tout de suite, je n'ai pas aimé cette keynote. Si le sujet de la place du développeur est intéressant, Thomas Gx l'a abordé en commençant par un cours d'histoire pour finir sur quelque chose d'assez évident : garder une ouverture d'esprit sur d'autres domaines (économie, philosophie,...) nous aide à progresser et trouver notre place dans la société en tant qu'individu et acteur de demain.
Parfois contradictoire, le propos ne m'a pas paru construit et je ne suis pas sûr d'avoir saisi la notion de développeur universel, pas plus que celle de développeur fullstack, d'ailleurs. Déçu au final de ne pas dégager une idée clé de cette keynote.

Demain j'arrête le café, je me mets au crabe

De bon matin, Logan Mauzaize (MonkeyPatch.io) et Alessio Coltellacci (Clever Cloud) nous présentent le langage Rust (dont la mascotte est un crabe). Du point de vue de la forme, Alessio et Logan se partagent chacun leur tour la parole sur les différents aspects du langage. Après avoir positionné Rust en comparaison des autres langages populaires comme le langage donnant le plus de contrôle et le plus de sécurité, ils nous expliquent les trois piliers autour desquels a été construit ce langage :

• Rapidité (d'exécution)
• Fiabilité
• Productivité

Le premier point est adressé par une compilation vers LLVM qui selon les speakers permettent d'atteindre des performances au niveau de C/C++.
La fiabilité est donnée par un système de types fort, avec générics, pattern matching et tout un tas de features encourageant la programmation fonctionnelle. Dans ce registre, Rust introduit deux concepts (pour moi inédits) : ownership & borrowing. Le concept est définir un owner pour chaque variable et de transférer le ownership à la fonction appelée. Si l'appelant réutilise cette variable, le compilateur indique une erreur de "move". Ainsi, la plus haute fonction dans la stack à avoir en paramètre la variable en est le owner et à la fin de son exécution, libère la mémoire associée : simple et très efficace. Borrowing permet de passer une variable en read only, sans transfert d'ownership. Un mécanisme plus avancé (borrowing + mut) permet de ne balader qu'une seule référence mutable sur une variable et positionner ainsi un lock au niveau de la donnée et non du code.

Pourquoi j'ai aimé

J'ai trouvé la présentation d'une grande qualité, à la fois sur la forme et sur le fond. Peut-être un peu rapide sur l'explication du concept de borrowing mais la présentation a bien donné les billes pour creuser tout ça (et puis bon, muter des variables, c'est pas mon truc !). Le périmètre couvert était en adéquation avec le timing, avec un choix de montrer du code, plus que de montrer l'écosystème et les outils autour (mais ceux-ci ont bien été mentionnés). Pas de live coding mais des exemples assez parlants. Au final, une bonne présentation, qui donne envie d'essayer Rust !

L'UX a sauvé mon DevOps

J'avais coché ce talk dès que j'ai vu que c'était des employés de TabMo qui présentaient, cette société étant connue pour utiliser Scala en interne et promouvoir la programmation fonctionnelle. Cette session présentée par Estelle Landry et Francois Teychene était un retour d'expérience sur la mise en place d'une équipe DevOps chez TabMo. Au programme, d'un peu d'histoire de TabMo, des problèmes rencontrés par des développeurs frontend, on a navigué vers la résolution de ces problèmes. Le talk a mis en avant les différentes cultures (celles des admin sys, celle des développeurs frontend et backend, celle du product,...) et montré que dans le cadre du talk, UX et DevOps, partageaient des valeurs communes. Dès lors, Estelle nous a expliqué comment on pouvait qualifier d'expérience utilisateur l'interface d'une équipe. Par exemple, avant d'engager une réflexion sur le sujet, l'équipe DevOps n'était pas intégrée à la roadmap et traitait les demandes au fil de l'eau, sans forcément adresser les réels problèmes. Les méthodes et ateliers venus du monde de l'UX ont permis d'améliorer le recueil du besoin et de changer l'interface entre équipe DevOps et les autres équipes. Au fil des slides (ou pas, pour cause de problème techniques), Estelle et François nous présentent divers ateliers qu'ils ont mis en œuvre afin que les équipes se comprennent entre-elles. À chaque fois, ils nous expliquent ce qui a marché, ce qu'il faudrait refaire ou ce qui n'a pas marché et pourquoi.

Une bonne surprise

Comme dit précédemment, je suis allé voir ce talk, principalement parce que c'était TabMo et qu'ils sont connus pour encourager la programmation fonctionnelle. C'est donc une bonne surprise que d'avoir suivi une session non-technique qui m'a évoqué tout un tas de problèmes que l'on rencontre chez mon employeur (et même ailleurs, je suis sûr). Au final, la présentation était très bien maîtrisée, avec du rythme, une bonne ambiance et une complicité à l'épreuve des problèmes techniques. On a eu droit à une tranche de vie de l'entreprise avec des idées pour développer la philosophie DevOps. Alors bien sûr, dans les maîtres-mots de cette présentation, je retiendrai le fait que la mise en place de DevOps résultait surtout d'une volonté commune qui, à force est allée au delà de simples mots. Le discours était bien structuré et présentait les différents ateliers menés sous forme de "on a fait" et non d'une recette de cuisine. C'est ce que j'ai aimé, ce côté : "on a tenté des trucs chez nous, ça a plus ou moins marché, inspirez-vous (ou pas), dans notre contexte, on est parti de là, et maintenant, on en est là".

Balade au pays de Let's encrypt

Après la session moins technique et plus "organisationnelle", nous revoilà dans une conférence très spécifique techniquement, bien que présentée de manière simple, et sans prétention de faire de l'auditoire des experts en crypto. Frédéric Cabestre nous parle dans son talk des certificats, avec un peu d'histoire et d'explications sur les concepts de base (chiffrement symétrique et asymétrique) puis sur l'infrastructure à clés publiques et sur la place de Let's Encrypt là dedans. On passe dans cette balade par la découverte du processus de signature des certificats. On apprend à lire les Certificate Signing Request et les Certificats, avec une foule de petits détails qui peuvent être utiles. Frédéric nous donne les clés (ah ah !) pour rentrer dans cet univers en utilisant le couteau suisse openssl. On apprend aussi comment est géré la compromission de certificats et les protocoles mis en oeuvre. Enfin, on aborde le sujet de Let's Encrypt, qui vient pour nous aider de manière automatique à signer des certificats (de courte durée) afin de populariser l'utilisation de HTTPS. La présentation se termine sur quelques limitations (pas de certificats génériques ni étendus, nombre de requêtes limités sur l'API) et sur comment les limites ne sont pas génantes en pratique.

Un talk utile

Si le sujet est en effet complexe, l'orateur est précis et ne noie pas l'auditoire dans des détails mathématiques quand il s'agit de crypto, ni de bouillie de protocole quand dans la suite du talk, il aborde la signature certificats. La progression de la théorie vers les cas d'utilisation de Let's Encrypt est linéaire et progressivement on comprend comment tout cela peut nous servir un jour.
J'ai aimé cette présentation et ma conclusion principale sera que j'ai appris des choses. Difficile de dire quand tout cela me sera utile, mais les bases et surtout où chercher sont là.

Quickie : Des portes logiques pneumatiques en bois

Dans ce quickie classé dans la catégorie WTF, Fabien Tregan nous parle d'un de ses projets DIY. On plonge dans le fonctionnement de l'orge de barbarie et de ses valves pneumatiques. Rapidement, Fabien nous expose qu'on peut voir ces valves comme des transistors, laissant passer de l'air ou non, selon un contrôle. Dès lors, Fabien nous explique les différentes étapes de conception afin de réaliser un assemblage de portes logiques que nous connaissons bien en informatique (AND, XOR, NOT, OR).

Un peu de making

Petit bijou de présentation que ce quickie, qui a fait plaisir au bidouilleur en moi. Le projet de Fabien est intéressant et faire des parallèles entre électronique et mécanique est original. Surtout, son approche à vouloir savoir comment ça marche et jusqu'où on peut pousser le concept est inspirante : dans nos métiers de développement, on se cantone souvent à utiliser un framework, dérouler des techniques, et très peu on se focalise sur ce qu'il y a à l'intérieur de la boite. Ce talk était une invitation à aller au delà, à creuser des choses que l'on pense acquises, et à jouer avec.

Plus loin avec Kotlin

Dans cette première session de l'après-midi, Arnaud Giuliani donne suite à son talk de l'année précédente qui introduisait Kotlin. C'était noté dans l'intitulé, cette présentation s'adressait à un public un peu averti déjà sur Kotlin. Pas de récap sur les fonctionnalités du langage, juste quelques news, comme la release de Spring 5.0 supportant officiellement Kotlin.
On passe alors à un cas concret d'usage avancé de Kotlin : la création d'un DSL pour faire de l'injection de dépendance en toute simplicité. Kotlin offre de bonnes possibilités (à la Groovy, mais avec du typage en plus !), On commence par un retour sur les fonctions let et autres goodies apportés par Kotlin sur tous les objets.

Effectivement, pas pour le débutant

La présentation portait comme son nom l'indiquait sur les aspects les plus avancés de Kotlin et sur la combinaison de ceux-ci. Dès lors, avec ma connaissance encore limitée et mon manque d'expérience/pratique de Kotlin, suivre complètement le talk fut difficile, mais néanmoins pas impossible. La partie la plus intéressante pour un néophyte Kotlin était finalement celle concernant le design à proprement parler du DSL.
Ce talk et la question d'une personne du public sur la comparaison avec Scala m'a conforté dans mon opinion sur Kotlin : c'est un langage "pragmatique". Pas de focus sur la programmation fonctionnelle en particulier, mais un tas de méchanismes se basant sur quelques notions que l'on connait bien en Scala.

BATTLESTAR GALACTICA: Saison 5 - Les Cylons passent dans le cloud avec Vert.x

Philippe Charrière de Clever Cloud présente le développement de microservices avec Vert.x, le toolkit polyglotte qui se voulait être la réponse à Node.js s'exécutant sur la JVM. Dans une mise en scène sur fond de Battlestar Galactica, on va développer des services en Java, Scala, Groovy,...

Difficile de se faire un avis

J'ai bien aimé cette présentation qui a montré les capacités de Vert.x. Un peu de live coding et par la même occasion, le fameux effet démo ont rendu quelques passages un peu hardus à suivre. Quelques concepts clés de Vert.x sont introduits (les Verticles), ainsi que la magie du framework : Service Discovery en particulier et quelques autres features.
À la fin de la présentation, j'ai trouvé Vert.x puissant sur l'exemple donné, mais je n'ai pas non plus eu toutes les clés pour me lancer dans une application Vert.x. Peut-être à essayer quand même, sans grande conviction ?

Functional Programming Explained to my grandma

Dans cette présentation, Charlotte Cavalier lance une introduction à la programmation fonctionnelle, en racontant comment elle l'a expliqué à sa grand-mère.
On part d'une analogie avec une recette de cuisine pour dérouler les concepts sympa qu'on retrouve en Scala...

Not for me

Bon, je n'avais pas de grandes attentes sur cette présentation, je m'attendais à un story telling du comment évangeliser le FP tout en en apprenant les bases au passage et j'ai été un peu déçu. Je n'ai pas vraiment appris de choses techniques. Si il est toujours intéressant de confronter la conception qu'on a déjà des Monoïdes, Monades & co à celle des autres, cela n'a pas été le cas lors de cette présentation. Je n'ai pas non plus bien appris une façon de présenter la programmation fonctionnelle à un néophyte. Dommage.

Quand nous avons emmené notre web app chez les Bisounours

Pour terminer la journée, je me suis dit qu'un talk fait par les gens de JFrog devrait être intéressant. Au programme, la mise dans le cloud d'Artifacory, le produit phare de l'éditeur.

Mouais...

Difficile de donner mon avis sur cette présentation que je n'ai pas suivi jusqu'à la fin, car il faut bien l'avouer, la forme et le contenu n'étaient pas au rendez-vous...

Keynote de clôture : Apéro fonctionnel

Concept importé de Devoxx France, Philippe Charrière de Clever Cloud réunit quelques autres speakers pour discuter autour d'un verre de la programmation fonctionnelle. On apprend petit à petit ce qu'est un monoide, de façon plus pragmatique que formelle. On développe les concepts de functor & co, le tout en rigolant.

Une touche de fun

Pas mal de finir sur une telle keynote, au ton très léger. On apprend des trucs sans prétention (pour ceux qui ne font pas de programmation fonctionnelle au quotidien) et on se pose les bonnes questions : "mais ton truc, là, ta monade, dans la vraie vie, ça donne quoi ?". Le talk donne au final un bon aperçu des discussions que l'on peut avoir sur le sujet autour d'une bière entre collègues puristes de la programmation fonctionnelle, ceux plus pragmatiques et ceux qui ne jurent que par la POO façon Spring Black Magic et les ORMs.

L'heure du bilan

Pour cette deuxième édition du DevFest Toulouse, l'équipe de bénévoles a mis le paquet : organisation au top avec accueil, restauration et pauses bien fournies en quantité et qualité. Du côté de la selection des talks, beaucoup de sessions Web et Mobile, et un gros programme aussi sur le backend, assez varié (chatbots, machine learning, languages). L'événement sait rester agnostique sur les technologies. Même le monde Microsoft était représenté.
Du côté des sessions que j'ai suivies, j'ai particulièrement apprécié la matinée, dense en contenu technique avec des présentations bien menées surtout. L'après midi, j'ai peut-être moins bien choisi mes sujets.
De cet événement ressort une forte envie de faire du Rust, de pousser un peu plus mes bases Kotlin (au moins pour m'en servir comme pivot pour sensibiliser à la programmation fonctionnelle).
Vivement l'edition 2018 !