Here you can download my Curriculum Vitae (PDF).

I also wrote a informal biography about my journey into programming.

Early days

I first started computing and programming in early 1990s. We mostly used MS-DOS at primary school; a few computers had Windows 3.1. My first programs were in QBasic. Soon after, I learned to write batch scripts (.bat) with their silly syntax (“IF ERRORLEVEL N…” that had to be written in ascending order, etc.). Finally, my brother entered high-school and learnt basics of Turbo Pascal 7; so did I.

In the middle of the 1990s, I had started reading computing books and was already a proficient Delphi 4 programmer (Delphi is the successor of Turbo Pascal on Windows). I spent hours on the news servers and During the same period – my secondary school years – I learnt basics of x86 assembly language. Like many other geeks, I wanted to write my own OS and so I read everything I could in order to understand how to do it: VESA standard, MS-DOS and BIOS interruption lists, etc. Later I would enjoy reading Intel’s x86 architecture manuals in my first year in high-school. Well, I enjoyed volumes 1 and 3 but skimmed over volume 2 (instruction list).

Internet and 3D

My parents live close to the Futuroscope attraction park (in France). At the time (late 1990s), we had a yearly substriction to access the park anytime and we enjoyed the Cyber Avenue “attraction” – it seems strange nowadays – which provided free access to Internet: I learnt HTML 4, Javascript 1.3 and finally CSS that became the new way to design web pages. Then I had a look at ASP and finally chose PHP – it was the time PHP 3 (with the .php3 extension) was being replaced with PHP4 – and I learnt SQL (MySQL) at the same time. Those days, Java applets were sometimes used to make cool effects on images and stuff like that: I read two books on Java 2 (well, 1.2) but I did not really like it and never made any applet.

At some point I wanted to know how to design 3D images. It must be around 1999 because the contemporary book I own is about 3D Studio MAX 3. It was interesting but not as much as programming with the ray-tracer POV-Ray. Anyway I only programmed a picture of a drumset (sadly I think I lost it) with POV-Ray, but it was very rewarding. It may explain why I am still very interested in ray-tracing. In 2009 I enjoyed the book “Ray-Tracing from the Ground Up” by Kevin Suffern and started the implementation of my own ray-tracer (SunBurn) in Scala.

Windows programming

Before my total switch to Linux – circa 2006 – I was basically a Windows programmer. In 2002 I wrote a software (with Delphi 5 or 6) called “Popup Killer” that used Windows hooks to destroy some windows when they were created. Network was badly configured at my high-school and the same popup kept appearing every 5 seconds: my soft has been popular for a while there. In the same high-school, I participated in a project in which we designed a talky-walky and I programmed the C part on the Atmel micro-controller. In 2003 I wrote two tutorials for Windows programmers: the first one to explain how to control Microsoft Excel from a Delphi program through the OLE interface and the second one to explain how to write raw bytes on a disk using Windows 2000 device file paths – my aim was to create a bootable floppy, in which I succeeded.

Software cracks were (and still are?) very popular among Windows users. I wanted to learn how it was possible to modify binary programs, without having access to their source codes. I read many tutorials, learnt to use the SoftIce debugger, Win32dasm and IDA pro disassemblers and practiced a little. This proved to be useful later when I worked on MAQAO (Modular Assembly Quality Analyzer and Optimizer) for which we use almost the same techniques to optimize high-performance programs on Linux. On the assembly side, my brother and I decided to reverse-engineer the Windows driver of our scanner to make it work under Linux: I worked for hours to convert the disassembled driver into C. The scanner, however, became obsolete before we succeeded in something more useful than making the scanner LEDs blink. I also wrote a software to extract resources (sounds, musics, images, etc.) from huge collection files found in games such as Final Fantasy VII, Doom or Commandos: the interesting part was to infer the format of the collection files. I used Delphi 7 and also gave a try at C# that was the new popular thing.

Linux language quest

After my full switch to Linux in 2006, I was a bit lost: obviously no Windows API, Delphi didn’t work under Linux, FreePascal wasn’t good enough for me and Kylix was very bad – not to mention the forced switch from the VCL (Visual Component Library) to the CLX. I tried to use C++ but coming from Delphi, it was (and still is) awful. I gave another try at Java (learning Java 5 and its generics) and even made my final project with it in the Classes préparatoires aux grandes écoles. There I also learnt the basics of Objective CaML (OCaML).

For a few years, I had been looking for a good language to use on Linux. I gave Ruby a try to write a simple script to download videos from a VOD platform: an irking experience. How could anybody work with this dynamically typed language that didn’t even support UTF-8? I learnt D language that was claimed to be what C++ should have been: a good experience… at the beginning. D had two incompatible standard libraries (I swear it is true). At the time, I had Lisp courses in engineering school: it was interesting but the syntax was unbearable. Moreover, we were taught to use “progn” and global variables, so what is the point in using a functional language with a strange syntax? We also learnt a bit of Prolog.


In 2008 I was still looking for a language that would suit my needs. Python looked just like Ruby, so it was a no-go. This new thing called Scala seemed quite good. It was half functional and I was not very fond of functional programming but it was also a better Java and quite similar to Delphi. I bought and read Odersky’s book during my internship at Medialog (the last Delphi I had used was Delphi 7 but there we were using Delphi 5: very outdated). I was quite efficient with it by the time I made my last year internship at Thales avionics in 2009 – porting a low-level communication middle-ware in C to cluster of IBM Cell processors (i.e. 8 PlayStation 3 with YellowDog Linux).

Scala was really fun: I used it to write a ray-tracer prototype and the first version of a runtime system prototype for heterogeneous architectures using OpenCL (using the continuation plugin) for my PhD. I was a subscriber of most Scala related mailing lists and wished I could make a post-doc at EPFL. People on the mailing list (well, mostly Tony Morris), however, were arguing that Scala developers were making some mistakes: look how Haskell did it right! They even wrote Scalaz which was hard to understand for someone with an imperative programming background: why would we want to use such strange functions and operators? Anyway I started reading about Haskell.

Scala was great but it had some issues: the over-complicated collection library, the workarounds for Java/JVM compatibility, etc. In addition, I had troubles with program design: should I use classes with member methods or pattern matching on case classes? It was difficult to make that choice and it was complicated to switch from one design to another. Paul Phillips – a major Scala developer at the time – made a talk called “We’re doing it all wrong” into which he summarizes many issues he encountered and I mostly agree with him. Finally the Haskell approach seemed more and more appealing; there is one way to do everything: functions.


During my PhD on programming models for heterogeneous architectures (GPUs, CELL, Xeon Phi, etc.), I read about many languages and programming models (PGAS, BSP, etc.). In my team, they were developing a runtime system based on task graphs. It had many drawbacks and I thought we could use functional programming to declare task graphs – functional programs are graphs. In addition I was convinced we could work out a way to automatically transform functional programs to enhance their parallelism. Indeed, the former is called implicit parallel functional programming and the latter is the topic of the Bird-Meertens formalism. All of this is from the 1980s but I enjoyed reading the papers and it became the topic of my thesis (well, the unofficial one because I got almost no support for it and I had to work on an OpenCL implementation – the trend at the time, that has been supplanted by the OpenACC one, that should be supplanted by another soon – for which I had almost no interest).

Finally I wrote a frontend prototype using Haskell to describe task graphs for our runtime system and I thought it was very promising. The existing runtime system had major limitations for what I planned to do, hence I started writing a new one from scratch totally in Haskell: ViperVM. I learnt to use the FFI and the STM. In addition I read papers on how to design compilers/interpreters for functional languages in order to develop a runtime system for implicit parallel functional programming on heterogeneous architectures. The first prototype was very basic but it worked well and I presented it at FHPC’13. In January 2014, I started a rewrite to make it a full-blown runtime system.

Exascale Computing Lab

I spent two years (2014-2015) in the Exascale lab in Versailles working on MAQAO (there are two forks of the software in the wild that should be open-sourced “soon” for at least 5 years). There we were using mostly Lua (awful) and C to manipulate binary programs (binary patching). I have also been using Haskell to develop side tools such as a data mining tool for the traces generated by our instrumentations. Its web interface was relying on HappStack.


In 2016 I became a freelancer and I started focusing on two projects:

  • Haskus system (initially named ViperVM): a low-level framework to directly use Linux, even bypassing the libc, with Haskell. Cf

  • Battuo: a drums practice webapp written in Haskell

These two projects led me to learn a lot about Haskell and GHC. I’ve started fixing bugs in GHC to allow static programs to run into Linux’s initramfs without any other library installed (e.g. no iconv, no libc). As I was scratching my own itches in GHC, I became a GHC developer.

Doing system programming in Haskell led me to spend quite a lot of time designing a variant type to handle sets of return errors from syscalls. I’ve learned how to use type families, GADTs, role annotations, etc.


In 2019 I’ve joined IOHK (now IOG) to work on GHC full-time. I’ve worked on:

  • ghc-bignum: a unified package for GHC’s Integer/Natural types. In particular I’ve made a pure Haskell implementation of these types that was faster than the exisiting integer-simple library.

  • modularity: refactoring the compiler to enable better cross-compilation support, documentation, and a saner code base. I wrote a whitepaper about the bad state of GHC’s codebase which was published with the welcome help of Jeffrey Young and John Ericson.

  • JavaScript backend: in 2022 I became team leader and I led the fusion of GHCJS’s code generator into GHC which was done for GHC 9.6 and really usable starting from GHC 9.8. As a new manager I read several books about management and got some training from LifeLabs Learning. As a father of a 1-year old, I also read many resources on productivity, time management, deep work, etc.

  • many other things: I’ve worked and I’m still working on many other things. In 2024 I’m still in the top 3 contributors to GHC in terms of Gitlab’s number of recent commits (I know it’s not the best performance indicator but still).

In Haskell we keep fighting against unecessary allocations to fix performance issues. This is tiring and got me interested into new languages such as Zig.