Blog | Lukas Barth

Building multi-threaded software in C++ has many pitfalls.

I recently ended up building a configuration system for a piece of C++ software I’m maintaining.

If you’re building software tuned for performance (in C++ or a similar language), you probably know this as a golden rule: Avoid memory allocations in your performance-critical code at (almost) all costs.

Emacs has been my daily driver for software development and various other tasks for quite some time.

Modern C++ has many neat RAII-based solutions for managing resources.

I currently build a piece of software which will need a lot of bog-standard SQL queries against an in-memory database.

I often encounter variations of the following problem: You are given two or more lists (as e.g. std::vector) of elements and you want to sort them “in parallel”, using one of the lists as keys.

If you build an application that uses large, contiguous amounts of memory, it can increase your performance if you allocate this memory in so-called huge pages.

In fact, CodeChecker is much more than just a front-end to Clang’s Static Analyzer (clangsa from here on…) - but using it just to drive clangsa is already awesome enough that I think you should use it to hunt for bugs in your C++ projects.

This blog now uses Carl Schwan’s great idea (and code) to add a comment section to this (static) website.

std::vector has the interesting property of allowing to be used with incomplete types to a small degree.

When optimizing code for performance, it is often useful to have a very clear idea about what happens in memory.

One C++17 problem I come across every now and then is to determine whether a certain class or function template specialization exists - say, for example, whether std::swap<SomeType> or std::hash<SomeType> can be used.

Up until recently, I pretty much exclusively used git as my VCS system.

I recently needed to trace some error related to C++17 class template argument deduction and came across some corner cases.