Projects which I am actually somewhat proud of
The one (very simple) thing I did that other people actually used: a script for formatting Weechat logs in HTML, written in Haskell (perhaps the best scripting language I know!). Théophile Bastian later turned this into a Weechat plugin.
Raising from the dead an experimental Lisp Machine processor for a hardware class (pretty ambitious for a school assignment). Joint work with Thomas Bourgeat (now doing a PhD in hardware at MIT). Includes :
- Caillou, a hardware description EDSL in Haskell (design taken from Lava 98)
- A circuit simulator which takes the netlist format outputted by Caillou
- The actual processor circuit and its microcode
- An assembler (note that the machine language is made of S-expressions, which need to be linearized into an array of cells with pointers to fit into the memory)
- A compiler from a tiny Lisp to machine code
- Tools used during development such as an emulator for the instruction set (written in imperative-style OCaml)
The length of this section would be pretty sad if I weren’t a self-identified theorist. It might stagnate in its current state since I don’t do much programming nowadays. I still plan to experiment with languages such as Rust and Erlang some day.
- (with Nicolas Blanchard) A C program implementing some ad-hoc heuristic algorithm to test graph isomorphism. The algorithm might be (but probably isn’t) more asymptotically efficient than Weisfeiler-Lehman on a small class of graphs.
- A compiler for a small subset of C to MIPS assembly (written in OCaml). The frontend was written with Nicolas Blanchard; I added a backend a long time after.
- (with Antoine Voizard) A collection of OCaml modules implementing a common interface for Kahn process networks. Showcases 2 different ways to implement cooperative multitasking in a functional language.
- (with Antoine Voizard) ML++, an ML-ish language with typeclasses, compiled to OCaml with dictionary elaboration. Constructor classes are compiled to functors (in the ML sense, that is, parameterized modules).
- An ant colony algorithm for the cutting stock problem, for a metaheuristics course.
- Implementation of algorithms: see dedicated page.
- An old program to play chess over the network, with a simple client/server architecture and a GTK+ GUI, written in Haskell. Someday, I’ll modify this to use modern functional programming techniques (using iteratees for network I/O and FRP for the GUI).
I used to write lots of small programs in high school, most of which were lost due to lack of proper backup discipline.