/ About Me

Programming languages

I've worked with lots of programming languages.

Recently, I focus on Rust and Python, with a dash of JS/TS.

Previously, I have done significant work in Perl and C++. As a programming language nerd, I have dabbled in tons of other languages as well.


Read posts tagged Rust.

Rust is my favourite language right now. It provides low-level power combined with a degree of safety and expressiveness that is absent in C++.

Even if it weren't for that speed and safety, the type system is often a joy to work with, helping with writing correct software on the first try.

But the best things about the language are not the language features, but its community, governance, and ecosystem:

  • a very open and inclusive development process (yes, even despite the regular drama),
  • rapid delivery of compiler updates with real-world improvements, and
  • the foundations of a great library ecosystem (crates).

Especially crates are a killer feature compared to C++.

I have done data science and web projects in Rust. I have a personal (non Open Source) project that is a web-based note taking application, essentially an Obsidian clone. The backend is written in Rust, split over a workspace of about 25 crates with 28 KLOC. It includes a web backend (Axum, previously Actix), GraphQL endpoints, a custom full text search engine, and of course the business logic of parsing and rendering notes and handling rich links between them. It's fair to say that a good amount of yak shaving is going on here. But it's also fascinating to work on a long-term large-scale project that I fully control, having to eat my own tech debt and having to architect dependencies for reasonable compile times in a way that just isn't a factor for small libraries.

In 2018 I wrote here:

It's a very promising language, but not quite there yet. There are a lot of rough edges, and many important features that are still nightly-only (experimental). In 5 years or so Rust will be great. Hopefully :)

Those five years have passed, and I think things have gotten a lot better, with Rust's async support having particularly high impact. But there are still lots of useful language features that are nightly-only, or safe things that can only be done with unsafe{} blocks.


Read posts tagged Python.

I'm not necessarily the biggest fan of all its design choices, but I really like Python features like docstrings, async functions, generators, and type annotations. More (dynamic) languages should steal those!

I came to Python via scientific programming and data analysis: munging data and plotting it with SciPy/NumPy/Matplotlib. I've also been doing a bit of old-school machine-learning work with Scikit-Learn.

I've learned a lot about evolving Python projects with lots of users by serving as a maintainer for the Open Source gcovr project, a code coverage report generator for C/C++ that's written in Python.

I like to use Python as a prototyping language, for example trying out a simple web app idea with Flask or similar frameworks.

JavaScript and TypeScript

I don't identify as a JavaScript programmer, but I know the language reasonably well and am familiar with modern development practices.

Technically, it was the first programming language I learned when I started dabbling with web technologies as a kid. That was back when Internet Explorer was still considered a good browser.

Of course a lot has happened since then. I've done a nontrivial amount of frontend work with Vue 3 and TypeScript.

I have some older blog posts involving JavaScript


Read posts tagged C++.

The language is so beautiful and so annoying at the same time. I have never written a nontrivial C/C++ program that didn't require me to debug a segfault. It's a difficult language. But when writing code in other languages I also dearly miss powerful C++ features like variadic templates or RAII.

I'm fairly comfortable with the C++14 edition and know the Core Guidelines, but didn't have the opportunity to use newer features like coroutines, concepts, or modules.

I gathered a lot of experience during a one-year stint doing testing, refactoring, build engineering, and other maintenance on a C++-based enterprise middleware product to connect various data sources in the financial industry.

I also used C++ for a systems programming research project developing more secure memory allocation techniques.

My experience with C++ also makes me comfortable with using C, which is especially useful for dealing with POSIX systems. C is a nice language if we forget about string handling with the standard library. Or creating any kind of abstraction. I prefer C++, thank you.


For a long time, my primary language was Perl.

I have a very comprehensive understanding of the language, and know both its elegance and its numerous flaws. I enjoy that this language is very pragmatic and doesn't have an ideological axe to grind.

I used Perl to explore and understand various topics and techniques.

Its flexible DIY approach to object-oriented programming helped me to form a deep understanding of OOP. For “real” code, I make heavy use of objects systems like Moose or Moo – I really miss these modules in any other language I touch.

The book Higher Order Perl by Mark Jason Dominus (mjd) was my introduction to functional programming. Admittedly, the Perl code is somewhat archaic. But it's a very good book that starts at basic FP concepts and progresses to rather advanced use cases, which I'll have to re-read sometime to finally get the full benefit. MJD was nice enough to publish a free PDF of his book, but since then I've bought a physical copy.

One of Perl's strengths is text processing. Its regex integration started my interest in parsing, but at that time I didn't know enough CS theory to make full use of them. Later, I found out about Marpa, an Earley-based parsing algorithm and Perl module by Jeffrey Kegler. You can read my articles tagged Marpa, especially my comparison of Marpa with other parser families.

At some point, I stopped hacking and transitioned to an engineering mindset. The Modern Perl book by chromatic was a pivotal experience and started my interest in code quality and testing. Perl has many awesome testing frameworks such as Test::More, Fennec, and a passable Test::BDD::Cucumber implementation.

I started my Open Source journey with Perl, bundling up some frequently used utility functions as Util::Underscore on CPAN.

Read my articles tagged Perl or learn more about Perl.


Java was the first language I set out to learn, and served as my introduction to object-oriented programming. I'm comfortable with Java8 features, and am well-versed in design patterns.

However, I haven't used the language professionally, and have very limited experience using build tools like Maven or Gradle.

Other languages

Beyond that, I have dabbled in a multitude of languages. I don't have a lot of deep experience, but I know the basics and can get up to speed quickly when needed.

  • I'm particularly fond of languages that support functional programming, such as Standard ML, OCaml, or Haskell.

    Of these three, I have the most experience with Haskell. I have some understanding of the type system, monads, and techniques such as point-free style and lenses. I still have to work on understanding I/O, and the various algebraic structures related to monads: applicatives, traversables, ….

  • Scala is extremely powerful and flexible. Before Rust, it would easily be my favourite language if it weren't for those excruciatingly long compile times.

    Learn more about Scala.

  • Golang (Google Go) is an exciting and very learnable language but sadly lacks many features that help with more complex code. At least it now has generics, which wasn't the case when I experimented with the language in the early 2010s.