BreizhCamp 2016

As each year, the BreizhCamp, the biggest developer conference in West of France tooks place in Rennes, but this year in March and we were there! All talks are recorded and will be available on YouTube soon but let’s wait with a quick highlights on some of our favorite talks.

The Era of API by Aline Paponaud

Brace yourself: software is eating the world, but APIs are gonna eat software!

Aline Paponaud gave us a great talk on ‘The Era of API’ in which she first came back on the definition of an API and all the important questions that come with like should we version our API or not? How to make it public? How to monitor it?  Whereas for the first question no definitive answer can be given as the debate is still raging in the API world, it’s pretty simple to answer the two others with more and more tools emerging to publish and manage your APIs like Swagger or Restlet.

Then she highlights the revolution bringing by APIs, especially when it comes to those new two-sided markets like Uber, Airbnb, etc. where the API is slowly but surely replacing states of middle management by connecting all users directly together. She ended with 7 steps to a successful transition: share a vision, engage your whole team around it, learn a lot (especially REST) before making to not reinvent the wheel, clearly identify your resources but feel free to adopt REST principles when needed, stay focused on your customers needs, structure your data (you’re not the only one to use them anymore) and keep in mind than front-ends are now entire application, and thought should be treated carefully.

Let’s react with Mathieu Ancelin

Curious about React? You should definitively have a look at Mathieu Ancelin‘s talk which is a great introduction to this more and more popular JavaScript library written by Facebook Engineers and open sourced in 2013.

Currently used by major actors like NetFlix, Coursera, Reddit, HipChat, Yahoo, … React is a graphic library, not a full framework like Angular JS is and is completely component oriented. Facebook claims to have 50000 of them in their applications!

After going back to all the basics we need to know on how to React works (usage of virtual dom, component lifecycle…), Mathieu talked us about React Native, the new hype framework in the mobile world. React Native is fully based on JS and… well, React as you’ve probably guessed 😉 It comes with all the traditional JavaScript ecosystem and can be fully integrated into a classic mobile application which allows every developer to code for the mobile part of the project.

To illustrate the power of each project, Mathieu has first live coded a Redis client with React, and then the same client but with React Native. Very impressive!

HTTP – The Next Generation by Raphaël Luta

There is a « small » revolution in the HTTP world: HTTP/2!

First, Raphaël presented the drawbacks of the first generation of the HTTP protocol aka HTTP/1.1. It’s slow, inefficient (lots of overhead, parallel connections very limited), complex (7 RFCs to define the protocol!). Some other actors came: Server-Sent Events and WebSockets to circumvent some of this weakness and to bring a better UX to the users. Raphaël explained how both works, what was the differences and some use cases for each.

Then, he dived into the heart of the subject by presenting HTTP/2. The goal of HTTP/2 is a faster HTTP by using with a better way the TCP layer. How HTTP/2 works? What is binary framing? How HTTP/2 streams work? How HTTP/2 improves performances? So, many questions Raphaël answered clearly with really nice animations and demos. I have especially liked the animations that explained HTTP/2 streams. There were great to grasp the concepts! Great talk! Thanks!

Immutability: from code to infrastructure, the way of scalability by Quentin Adam

In this talk, Quentin explained us what are the drawbacks of mutable data. The data can have multiple states: reading, nothing, updating the value and lock (which is often a bottleneck). On the other hand, immutable data have two states: defined and undefined. Two states, so fewer issues, and pains… Immutability applied to the data can be found in NoSQL databases. Indeed, with some of them, there are no more update or delete: a new row with the modification is added. The row is immutable. This can be enforced with some coding patterns such as CQRS (Command Query Responsibility Segregation) that is promoted by the LightBlend (formerly TypeSafe) with their framework Lagom. If immutability can be applied to code, it can be applied to infrastructure. Split data and process. If you do so, you can kill your server at will, update the OS, etc. without fear. It was a nice talk too! With nice animated gifs, Quentin loves so much 😉

RabbitMQ 101: job scheduling, microservices communication, event-based data stream… How to cook the rabbit? by Quentin Adam

Another talk of Quentin. This time, Quentin explained the need for message brokers (applications communication, eventing, routing, acknowledgment, etc.). He then described us the different concepts of RabbitMQ (publishers, consumers, channels, exchanges, etc.). The second part of the talk dealt with how this broker works, with which topologies you can use, which use-cases can be solved with RabbitMQ. Very interesting. Quentin then finished with feedbacks. How it is used at CleverCloud to handle millions of messages. And as at, Quentin had a blackboard to draw nice schemas 😉

Quentin drawing nice schemas on a blackboard

Mob programming, promesses tenues by Maxime Sanglan

In short, Mob programming is pair programming at the team level. Well, a bit more than that. Basically, you gather your team in a room with one computer and one keyboard. Video projector and white/blackboards are welcome too. And you start working on a feature of your backlog. Not on a “Hello World”: a real feature that covers pretty much the whole coding process (testing, building, packaging, etc.) if possible. You’ve got a “navigator”, who will express his/her vision of how to code the feature and guide the “driver”. The driver is the guy or the girl who has the keyboard and types code according to the navigator guidances. The rest of the team is the audience and is open to the discussion, comments, and advices. Then, at regular time intervals (every 5 to 7 minutes), you rotate: another team-mate becomes the navigator, another one the driver and so on. The session needs a preparation though. Like a scenario that can be “played” during the session. Assets of this methodology: sharing, sharing, sharing! The whole team shares the same coding conventions, shares some good practices, shares the understanding of the feature, shares how to code unit tests, build the project, and so on. It seems so many advantages that some teams work in mob programming full-time. It was really a nice presentation with an interesting feedback from Maxime. It looks like lots of people like the subject: there were lots of questions. The talk makes me want to try with the team…

Træfik by Emile Vauge

Emile gave us a short presentation on Træfɪk, a new reverse proxy written in Go. Support of configuration hot reloading and the ability to plug containers / micro-services technologies such as Docker, Swarm Mesos, Etcd, Consul, Zookeeper, etc. are the strength of this newcomer in the world of the reverse proxy. Add some nice features such as circuit breakers, replay, automatic SSL with Let’s Encrypt, and you’ve got a tool that is worth having a look at.

Le Réseau, cet inconnu au centre de vos applications by Raphaël Luta

The network is often the poor relation in the skills of application developers. This talk is definitely for them! After presenting the characteristics of the network (Bandwidth, Latency, Error rate, Duplex, MTU, Jitter, BDP (Bandwidth x Latency)), Raphaël detailed how the protocols UDP and TCP works. Then, latency and window congestion were the main courses. Raphaël ended then with freshing tips, examples, and tools to use to test and debug network issues. Really a nice presentation to watch! I’ve enjoyed it, thanks!

Le hasard fait bien les tests by David Pilato

Chance can help you to improve your tests. That’s what David demonstrated at BreizhCamp. Has the following piece of code a chance to fail?

int input = generateInteger(
int output = Math.abs(input);
assertThat(output, greaterOrEqualThan(0));

Introducing randomness in your tests can help to detect bugs. David showed us how to use a small library that helps doing that: CarrotSearch’s RandomizedTesting. This library offers lots of random features: int, boolean, Strings, TimeZones (this one is great!), Locale (this one too!), Charset, etc. With few annotations, you can configure how many times to run random tests, how often (e.g. the @Nightly annotation) and some other goodies. This swiss army knife can be integrated with Maven or Gradle… David ended his talks with a feedback about how they use it for the Elastic products. Quite impatient to try this! Oh, by the way, yes, the above code can fail…

A last word…

Food and drinks at BreizhCamp 2016
A last word about the organization. The number of attendees grew for this session 2016. And it’s not always easy to welcome more than 500 attendees and speakers. The BreizhCamp team made an amazing job!

Food and drinks were so good, booths were nicely accessible, Meet and Greet and after parties were great!


Many thanks for this new fantastic edition! Hope to see you next year!


**Original source: blog


Please enter your comment!
Please enter your name here