Vendredi dernier, j’ai eu la chance de pouvoir participer au premier BreizhCamp, organisé entre autres par Nicolas de Loof. Cette journée, agrémentée d’un temps « breton », fût très enrichissante, tant par les conférences elles-mêmes que par les discussions que nous avons pu avoir entre ces sessions.

Une des particularité de cette journée était de ne pas tourner qu’autour de Java, mais aussi d’autres langages (Python, Ruby, .NET). Autre particularité (par rapport à la What’s Next notamment), les thèmes de cette journée étaient moins orienté Cloud, et plus NoSQL.

Voici un petit résumé des conférences qui m’ont le plus intéressé :

La keynote

La journée a commencé très fort, avec une keynote de Sébastien Douche sur les communautés. Après un rapide historique des communautés internet (Newsgroups, IRC, mailing-list, etc.), il nous explique l’intérêt des communautés :

  • Trouver de l’information fiable rapidement, en s’adressant directement à « ceux qui savent, qui font, qui réfléchissent »
  • Progresser plus rapidement que tout seul
  • Elargir sa vision des choses, et devenir plus créatif, en échangeant avec des personnes qui font différemment
  • Se constituer des réseaux d’amis, où l’on devient reconnu par son implication

Parmi les outils de « réseautage », Twitter est particulièrement intéressant. Contrairement à la plupart des autres réseaux sociaux, il permet d’avoir deux communautés distinctes : les personnes que l’on suit et les personnes qui nous suivent.

Faire les choses en communauté, c’est plus efficace, mais surtout, c’est plaisant. Alors comment importer ce modèle en entreprise, pour avoir plaisir à travailler 8 heures par jour (au moins) ? Plusieurs pistes, mais difficiles à appliquer par chez nous car opposées au modèle hiérarchique français :

  • Tout d’abord, permettre l’accès aux communautés externes (ah… nos chers PALC d’entreprise)
  • Valoriser l’initiative, la créativité, la prise de risque
  • Avoir un modèle de collaboration ouvert, sans mettre de frontières entre les services, et former des équipes multi-disciplinaires communiquant beaucoup (tiens, ça rappelle le DevOps ça…)

Conclusion de cette keynote : adhérez aux communautés !

Je partage complètement les principes exposés par Sébastien dans cette keynote : en commençant à participer au Paris JUG il y a maintenant plus d’un an, j’ai effectivement pu constater tous ces bienfaits !

Les présentations

Après cette keynote, 7 conférences se sont enchaînées dans la journée, entrecoupées de discussions et d’un déjeuner galette/crêpe. Voici la liste des présentations auxquelles j’ai participé qui m’ont le plus intéressé :

Le déploiement continu

Claude Falguière nous a présenté deux retours d’expérience sur la mise en place du déploiement continu.

Cette présentation m’a particulièrement plu, car elle présente bien les étapes d’amélioration du processus de développement/déploiement, et explique bien l’intérêt de la mise en place des bonnes pratiques (qu’on a parfois du mal à défendre auprès de certaines directions) :

  • Les tests (unitaires, d’intégration, etc.)
  • Le « fast-fail », lié au tests, permettant de découvrir les problèmes au plus tôt et ainsi de limiter leurs impacts
  • l’intérêt d’avoir un retour au plus tôt des utilisateurs
  • etc.

Le langage Python

Après la keynote, Sébastien Douche nous a présenté le langage Python, ou plus exactement pourquoi il aimait ce langage.

Un langage est un univers : il est accompagné de paradigmes, d’une philosophie, qui incite à coder d’une manière ou d’une autre. C’est cet ensemble qui fait qu’on aime ou non un langage.

Les avantages du langage Python :

  • concis, mais tout en restant lisible (certains langages ont des syntaxes parfois tellement concises et « magiques » qu’elles en deviennent illisibles)
  • homogène : le langage pousse les développeurs à faire les choses d’une certaines façon. On peut essayer de faire autrement, mais on développe alors de façon « non pythonique » (en ne respectant pas l’esprit du langage)
  • explicite et simple : quand on lit du code Python, on comprend directement ce qu’il fait (31 mots clés seulement, pour un manuel de référence de 100 pages)
  • extensible

Sans être un langage purement fonctionnel, le Python est un langage first class : les méthodes peuvent être passée en paramètres ou être retournées (ce qui manque cruellement au Java, et que j’apprécie donc particulièrement en Scala soit dit en passant).

La présentation se poursuit par une présentation du duck typing, possible en Python. J’avoue ne pas être particulièrement par cette possibilité : je préfère un typage plus fort, certes plus contraignant, mais donnant un code plus facilement compréhensible.

Cette présentation n’a pas été sans quelques trolls, mais il est vrai que les discussions avec Sébastien sur les différents langages étaient particulièrement intéressantes. Il a en particulier pointé plusieurs travers du monde Java, qui sont assez vrais :

  • ce monde est tellement vaste qu’on a tendance à ne pas trop avoir tendance à regarder ce qui se fait à côté, même si c’est en train de changer ces derniers temps
  • les développeurs Java ont tendance à plus se focaliser sur la technique et la « tuyauterie » des programmes que sur l’aspect fonctionnel sur lequel ils travaillent

Les bases de données

Au cours de cette journée, j’ai assisté à 3 conférences sur le stockage de données : deux présentations sur l’écosystème Hadoop et sur Cassandra, ainsi que la présentation de Julien Dubois sur le choix d’une solution de stockage. En particulier, j’ai beaucoup apprécié cette dernière conférence, très didactique autour d’une présentation des différentes façons de répondre à la problématique suivante, lorsqu’on commence à avoir de nombreux utilisateurs en même temps :

  • un ensemble d’évènements
  • des personnes participant aux évènements, et ayant entre eux des relations d’amitiés

L’application doit afficher pour chaque évènement auquel l’utilisateur participe, la liste de ses amis participant à ce même évènement.

L’approche naïve en SQL, c’est une requête composée de deux jointures. Là où ça se corse, c’est quand la volumétrie et le nombre d’accès concurrents augmentent…

Julien nous a donc passé en revue un certain nombre de solution (à choisir en fonction du contexte et de ses contraintes : ACID ou non) :

  • Un serveur SQL traditionnel simple (Oracle)
  • Un cluster de bases SQL (master-slave, façon MySQL)
  • du Oracle RAC (monnayant quelques bras)
  • une couche ORM (Hibernate par exemple), utilisant les bénéfices des caches de premier et second niveau (Ehcache, etc.)
  • les solutions de cache distribués, qu’il soient gratuits (Memcached) ou propriétaires (Terracotta, GemFire, etc.)
  • une solution NoSQL, avec la présentation de Cassandra (qui fait d’ailleurs partie de la solution avec laquelle Julien et son équipe sont parvenus en finale du challenge de l’Université du SI.

Epilogue

Cette journée s’est terminée par une mise en pratique fort sympathique de la keynote du matin, en communauté :

Quatrième (voire cinquième) mi-temps

Quatrième (voire cinquième) mi-temps

Prochain grand rendez-vous le 16 septembre pour le JUG Summer Camp : et il reste des places !