I am a senior software engineer interested in solving hard problems, from low-level performance to tooling, have the most impact on the end user experience, by writing pragmatic code that scales well and is easy to maintain and extend.

While having a lot of experience with C++/Python/JavaScript, I do prefer to use the Rust programming language, the best combination of productive, safe and fast, which I’ve largely used for almost 10 years. I am always eager to acquire new skills, so I’m definitely open to learning any modern tech stack.

I do love companies that promote decentralization, protecting the privacy of users in general, democracy, take a stand for social justice and/or try to actively fight global climate change.

I work best in small teams, when I have both lots of autonomy to explore and experiment, as well as close members with whom I can share and receive feedback on technical designs and random ideas.

I am open to freelance contracting opportunities at this point. Feel free to reach out!

🔗Experiences

🔗Element — (May 2023 — present)

I’ve been working on the Matrix Rust SDK, that is used in the rewrite of the ElementX mobile applications, at the heart of the company’s strategy. In particular, I’ve worked on the implementation of the new super fast sliding sync protocol in the SDK, fixing bugs and adding test cases, optimizing the performance, and giving feedback in the specification and to the backend teams. I’ve also worked on a major re-architecture of the SDK, including implementing a cache for storing events received from the decentralized Matrix network, which has been a core component opening the path to many new features (notably discussion threads, for which I’ve also added support in the SDK).

In addition to that, I’ve helped consolidate the tooling and testing infrastructure for the SDK, unifying our practices and helping grow our code level quality overall: Sentry integration, better testing framework, TUI example binary that allowed us to try features quicker, and so on. I’ve shared best practices from previous work experiences, in the form of deep code reviews and good regression and integration testing habits.

I’ve also had the chance to give a few talks about the Matrix Rust SDK at FOSDEM and the Matrix Conference, providing a high-level view of the SDK and novel features we’ve implemented in it over the last few years.

🔗Embark Studios — (Mars 2021 — April 2023)

Worked on a new internal game engine that uses WebAssembly mods.

• Designed and implemented new core capabilities in the game engine, enabling the rest of our internal game dev team.
• Contributed upstream to many open-source projects that we use. Notably, extended the Wasmtime virtual machine to support Apple Silicon. I’ve also worked on compile-time improvements, including an incremental compilation cache that lowered cold compile times up to 20% for a large single module, and for which cache hits would reduce compile times for a module by up to a factor of 10.
• Implemented in-game admin features and majorly contributed to a full redesign of our multiplayer architecture.
• Maintained and implemented various tools to increase team productivity: Github bot, Rust analysis tool, proc-macros for WebAssembly bindings generation, misc command-line and script helpers.

🔗Mozilla — full-time job (January 2014 — January 2021)

🔗Cranelift & Wasmtime (Rust)

• Implemented and maintained the Cranelift wasm backend in Spidermonkey (Firefox’s JavaScript engine) for years (glue code, compile-time improvements, features impl, etc.).
• Ported Cranelift’s meta DSL from Python to Rust, simplifying it, eliminating classes of potential footguns.
• Implemented a fast linear scan register allocator in Rust, for usage in Cranelift.
• Participated to the implementation of the new backend targeting Aarch64. Wrote the new backend variant for x64, including enough features to run the whole WebAssembly MVP test suite.
• Set up fuzzing for our new register allocators, using a toy language (parser, execution semantics) and libfuzzer.

🔗Firefox (C++)

• Added Float32 support to asm.js
• Added SIMD.js support to asm.js, and benchmarked performance, with results presented in a technical Mozilla blog post.
• Implemented support for WebAssembly in Firefox: decoding, translating to internal intermediate representations, adding support for new features, generating machine code (x64/x86/arm32/arm64).
• Made WebAssembly function compilation much faster in Firefox by using parallelization; then even reduced further compilation overhead by batching work according to heuristically determined bundle sizes.
• Made WebAssembly to regular JavaScript calls up to 50% faster by removing implementation details in the VM. Then made calls from JavaScript to WebAssembly blazingly fast (as fast as calls from JS to JS). See blog post.
• Implemented a domain specific WebAssembly fuzzer, trying to cause runtime assertions or crashes in debug builds, as well as comparing results of a same program across different platforms or architectures.
• Added Rust build support to the Spidermonkey build system, with all the possible configurations on all the different OSes supported by Firefox.

🔗Misc:

• Was the principal maintainer of AreWeFastYet, a cluster of machines running performance benchmarks of web browsers, as well as a website showing results in a meaningful way.
• Gave several talks about WebAssembly and its future, presenting the project to Web developers.

🔗Mozilla — internship (April 2013 — September 2013)

• Platform Engineer Intern, in the JavaScript Engine team.
• Added a new type to both the Just In Time (general JavaScript, “IonMonkey”) and the Ahead Of Time (specialized for asm.js, “OdinMonkey”) JavaScript compilers. Changed all architectural levels, from intermediate representation to code generation. Designed an algorithm in SSA form that ensures whether we can run optimizations regarding this new type.
• Benchmarked these changes and obtained up to 50% speedup on some real world applications (C++, ARM, x86 and x64 assembly).
• Wrote a blog post on Mozilla’s technical blog to talk about it: link.
• Added support for the Linux tool “perf” to OdinMonkey.
• Various bugs fixing (crashes, misbehaviours).

🔗Thales Research and Technology (May 2012 — August 2012)

• Designed and implemented generic, flexible parallelization tools for an opensource framework of metaheuristics called Evolving Objects, using C++ and Message Passing Interface (OpenMPI).
• Implemented generic, configurable, ready to use, convenient tools for parallelizing the evaluation step of genetic algorithms and for starting multiple times the same algorithm with different initial parameters.
• Used these tools on an opensource temporal constraint planner called Descarwin DAE (Divide And Evolve), ran the software on a heterogeneous cluster of 250 cores and performed statistical analysis of performances so as to prove the efficiency of parallelization.

🔗Atos Worldline (May 2011 — August 2011)

• Designed and implemented the frontend part of a secured webmail for a CRM, using Java / J2EE, Google Web Toolkit (GWT) and Spring Security for the server side, HTML / CSS / GWT for the client side. This webmail, optimized so as to be fast, was generic enough to be ready to use for any new customer.
• Designed and implemented tests for the server side thanks to JUnit.
• Added basic roles management system to another secured webmail, using the same technologies.

🔗Open-source experience

• 2022 — present: Maintainer of the cargo-machete quick cargo tool to reduce the number of unused dependencies in Rust projects, with a dedicated Github Action, used in many Rust projects’ CI.
• 2014 — present: Kresus, an open-source personal finance management project I’ve created, able to automatically fetch bank information from banking websites, gather this into a consolidated view of all accounts, and create charts/graphs based on this data. Around one thousand of npm downloads per week. I’ve been one of the two most active maintainers lately on this project, which also has a vibrant community of users self-hosting it on their own servers.
• 2014 — present: maintenance of a server with self-hosted services for friends and family, which involves sysadmin and Docker containers.

🔗Formal training

• Computer science master’s degree @ INSA de Lyon.
  • Including a semester-long exchange at the New Jersey Institute of Technology (NJIT).
• Bachelor in computer sciences and maths @ Université Lyon 1.

🔗Skills

🔗Tech stacks

• Matrix: expert. My time at Element implied learning to use some low-level details of the Matrix protocol, namely the Client/Server API, event definitions, semantic behaviors, and so on and so forth.

🔗Programming languages

• Rust: expert. I’ve been using the language since 2017, followed his evolutions, and worked with it in many different contexts: low-level platform code, video games engine as well as SDK code. It is my preferred language, at the time of writing.
• WebAssembly: expert. I’ve been involved in the initial standardization process, and I’ve been following evolutions of the standard since then.
• JavaScript: advanced. I’ve worked on the Spidermonkey JavaScript virtual machine that is used to process JS code in Firefox, and I’ve extensively used JavaScript on a personal project. Also have some experience with TypeScript.
• C/C++: great knowledge. I’ve used those when working on Spidermonkey, and while they’re not my favorite, I could probably learn how to use them again.
• Python: great knowledge. I’ve used in multiple personal projects, and I’ve had a formal training on the topic when I’ve worked at Mozilla.
• Java / Go are languages I’ve used in the past and that I would be strongly willing to get back to.