Let me tell you how I ended up giving talks.
It started in 2009, with my first job. Some colleagues took me along to a meetup, I got a taste for it, and I kept going back. Then, in 2010, I went to my first big conference: Symfony Live in Paris! The people on stage really impressed me. I wanted to learn everything: to know the Web standards inside out, from HTML and CSS to JavaScript and HTTP. And to follow the people doing the most interesting things with them. Between conferences, I burned through talks online and articles. Among the people who inspired me the most, and still do, you will find Jake Archibald, Marcin Wichary, Lea Verou, Bret Victor and Jeremy Keith.
In 2012, I was offered a Web and JavaScript module to teach at ISEN, my old engineering school. I did it two years in a row: twelve four-hour sessions each year, lectures and lab work. It ate up an enormous amount of time, and I loved every minute of it. Preparing those courses meant digging into Web standards as deep as I could, before I dared pass them on. Asynchronous JavaScript and closures were by far the hardest parts to teach. That's also when I started experimenting with my own slide tool, because of course I did.
In early 2013, I started submitting talk proposals to conferences. Nothing but rejections, my ideas were probably a bit too niche, and I had no idea how to write a good proposal. So I gave a talk at a local meetup instead. After two years of teaching, preparing it scared me a lot less. The audience, though, was nothing like before: the room had gone from students to people who did my job, probably better than me, and I had everything to prove.
At the time, I was working with Cyril Lakech. He is the one who suggested we submit a talk about Git to the Devoxx France call for papers, for 2014. I owe him one: we got accepted, and it went really well, with plenty of stress of course. That same year, Paris Web accepted me for my first solo talk. And that was it: year after year, I stayed hooked.
Sharing what I learn, telling stories, experimenting with how to present, and building my own slide tool along the way: that's what all of these talks are made of.
Since 2024, not a single new talk: nothing prepared, nothing given. I still want to, but there isn't much room for it right now, at work and at home. It will come back, I think. In the meantime, they are all below, most recent first.
with Antoine Caron
All day long, servers compress and browsers decompress, and hardly anyone looks under the hood. Using a Scrabble board as its running analogy, this talk takes apart the two algorithms under gzip and brotli: Huffman and LZ77. It shows how servers and browsers negotiate over HTTP, puts orders of magnitude in perspective, and closes on tips about the settings to apply on your own site.
Given 7 times between 2023 and 2024
All day long something between a tab and a server keeps a copy of your responses, and most of us only find out how when we hear ourselves telling a user to clear their cache. This talk reads the rules of the HTTP cache out loud: what each directive actually says, how a cache decides whether the copy it holds is still fresh, and what changes the moment that copy sits on a CDN instead of in a browser. It walks the whole line of caches between the tab and the origin server, private and shared, alive and dead, and ends on the handful of recipes you can paste into your own responses. The line is drawn as a metro map, and nothing on it is described without being run live, across three browsers and four caching proxies.
Given 5 times between 2022 and 2023
Adding one dependency to a web page now takes Node.js, npm and a bundler. This talk goes back over the concepts those tools brought with them, from minification to code splitting, and asks of each whether it serves the person loading the page or the person writing it. Then it reports on the smart CDN we built at Clever Cloud to get our Web Components back to a single script tag, climbed one optimisation at a time until it matched a bundled build. Four hand drawn road signs sort the techniques, and every gain is a filmstrip rather than an opinion.
Given 4 times in 2021
Frontend tools come and go, and what we throw away with them is the code we wrote around them. This talk takes a modern Web framework apart shelf by shelf, component system, templating, CSS, DOM, rendering, routing, state, and asks of each shelf what problem it solves and what it costs to stop using it. It stands the Web Components standards next to those shelves, limits and all, and lands on a better question than which framework won: how much does it cost to change your mind? All of it staged as a session of group therapy, because it started out as a rant.
Given 7 times in 2019
Every site on the Web asks you to accept them and almost nobody can say what one actually is. This talk goes back to 1994 and takes the HTTP cookie apart: where it came from, what a browser really checks before it sends one, and what Secure, HttpOnly, SameSite and the cookie prefixes are each fencing off. It ends on the other side of the same mechanism, tracking and privacy, down to the identifier a server can plant with no cookie and no JavaScript at all. It is told as a detective story, and nothing in it is described without being run live, on four hosts built for the occasion.
Given 11 times in 2018
Can two Web pages on two different laptops talk to each other with no server anywhere between them? This talk answers that question with sound. It takes WebRTC apart as far as the one thing its specification deliberately refuses to standardise, puts WebAudio on both ends of that hole to produce tones and read a spectrum back, and rewrites a connection offer in the base of a 24 tone alphabet so it fits down a channel made of air. It is told as the story of a side project, warning slides, a Super NES controller and live ultrasound included.
Given 5 times in 2017
with Ludovic Fernandez
We ship code with editors, version control, reviews and pipelines, and then write the documentation in a word processor and mail it around. This talk takes that apart in three acts, writing, collaborating and publishing, with AsciiDoc for the source and Asciidoctor for everything downstream of it: what a lightweight markup language buys you over HTML, DocBook and LaTeX, what git does to a text you would otherwise track by hand, and how one file becomes HTML, PDF, EPUB or slides. It is told through the one author I could interview at length, my father, who has published six popular science books and does every round trip with his editor in Word, by email.
Given 8 times between 2016 and 2018
Centring a block vertically should not be an achievement. This talk walks through what CSS gave us to place boxes before flexbox, vertical-align, floats and the libraries built on top of them, then takes the flex container apart property by property: what flex: 1 really sets, how the axis flips, where the leftover space goes. It ends on the layout that made the case in 2016, a back office that fills the window. Half an hour, no slides at all, every declaration typed live in an editor.
Given 5 times between 2016 and 2017
A session identifier is a token somebody else has to look up for you. A JSON Web Token carries what it claims plus a signature that proves it, so any service holding the key decides on its own. This talk takes the format apart claim by claim, weighs what statelessness buys against what it costs, from load balancing that stops being a problem to a token nobody can take back before it expires, and works out where to keep one in a browser without handing it to the first injected script. Told through a Lemmings level code, written down and typed back in the next morning.
Given 7 times in 2016
A Progressive Web App starts its life in a browser tab behind a plain URL and ends up on the home screen like a real app. This talk takes the term apart: the ten attributes it was given when it was coined, the Service Worker under all of them, which is a programmable proxy inside the browser with a cache of its own, and the manifest and the install prompt that put an icon on a phone. It weighs native against Web on the terms people actually choose between them, and closes on what a handful of developers had already done with a proxy nobody had asked for. Told through one week of a ski holiday, service by service.
Given 12 times between 2016 and 2017
There is a right order to watch Star Wars in, and it is not the one printed on the boxes. This talk takes the two obvious answers apart, release order and episode order, shows the single shot that breaks the first and the two twists the second gives away, and argues for Rod Hilton's machete order instead: IV, V, II, III, VI, with episode I removed rather than moved. Delivered as an ignite talk, twenty slides at fifteen seconds, which leaves no room for a caveat.
Given twice in 2015
A Web app that only works while the network does is a Web app that stops working several times a day. This talk takes apart what the browser had to offer instead: AppCache, and why it could not be repaired; the Service Worker that replaced it, a programmable proxy sitting between your pages and the network with a cache of its own; and the Cache API, fetch and the install and activate lifecycle you drive it with. It weighs what that closes between native apps and the Web, three months after the API first shipped. Told through a trip to the newsagent in 1993, because the round trip you do not have to make is the whole idea.
Given 9 times in 2015
If you try every value a CSS property will take and ship as soon as the page looks right, this one is for you. CSS is not a language for designers, it is a rule engine, and four rules decide where a box lands: display and the normal flow, the box model and what really sets a box's size, position and the cost of leaving the flow, float and clear and the container that loses its height. Twenty minutes, no slides, every declaration typed live in a browser.
Given 3 times in 2015
A second screen stopped being a designer's privilege years ago, and our Web applications still behave as though there were one window in the world. This talk starts on what the ergonomics studies actually measured and what attention costs, walks through the uses a second screen already has, then takes apart the five browser techniques that let two windows of the same application talk to each other with no server between them, and what each one asks of you in return. The last two editions were almost entirely live coding.
Given 5 times between 2014 and 2017
with Cyril Lakech
Everybody uses git, and far too many of us use it like SVN. This talk argues that a commit history is a document you write for other people, takes apart the commit message convention we borrowed from the AngularJS projects, weighs merge against rebase without pretending the debate is settled, and shows the six things git rebase -i lets you do to commits you have already made. It ends on a tool that turns those messages into a changelog, and it ended on stage with the two of us rewriting a real history live.
Given 9 times between 2014 and 2015
Before the browser had a memory worth the name, everything anybody wanted to remember went into a cookie. This talk opens the whole shelf of 2013 instead, one item at a time: the cookie, the URL hash, the window.name hack, Web Storage, IndexedDB and AppCache, what each one holds, what it costs, and which of them the server gets to read. It ends on the one thing none of the others could do, which is working with no connection at all. Told from the front page of a free daily, because my boss made me put HTML5 in the title.
Given once in 2013