Apple’s laptops have been making quite the splash since the end of
2020 and have made a massive comeback as a professional tool one year
later with the M1 Pro and Max designs. Most of the reviews I have seen
focus on the editing and rendering capabilities of these new MacBooks.
A few reviewers throw a compile test in the mix, but compiling
Chromium or any other huge project is only a part of the equation.
Developers don’t just compile code; they also use tools and IDEs to
develop their software.
Being new to the M1 world, I wanted to recap my experiences so far
briefly. I use Java professionally, and I also have a C++ application
based on the Qt framework that I wrote an eon ago and still use
productively. Being a former C++ professional, I am about native
performance, and I like native software. Therefore, I intended to
utilize as many Apple Silicon-native tools as possible. Luckily, one
year after its release to the desktop world, the most popular
applications have caught up. Let me go through my tool suite one by
The next major version of Qt6 was released about two weeks ago, and I
wondered how to get it to run on Linux. It is pretty simple on
Windows because almost everything is based on an installer, and so
the Qt installer fits in nicely. On Linux, however, where everything
is package-manager based, how would you go about it there?
Quick one: Set the proper CMAKE_PREFIX_PATH value for Qt5 development on Windows 10
with MinGW and CMake.
Here is the lovely error you get from CMake.
CMake Error at CMakeLists.txt:13 (find_package):
By not providing "FindQt5.cmake" in CMAKE_MODULE_PATH this project
asked CMake to find a package configuration file provided by "Qt5",
CMake did not find one.
Could not find a package configuration file provided by "Qt5" with
the following names:
Add the installation prefix of "Qt5" to CMAKE_PREFIX_PATH or set
to a directory containing one of the above files. If "Qt5" provides a
separate development package or SDK, be sure it has been installed.
CMake asks you to tell it where to find the Qt5 *.cmake configuration
files. One option is to set the CMAKE_PREFIX_PATH variable. The
Qt5 documentation has the following to say about that:
The easiest way to use CMake is to set the CMAKE_PREFIX_PATH
environment variable to the install prefix of Qt 5.
Now, what the hell is the "install prefix"? It turns out it is the
path where you can find the compiler-specific Qt binaries, include
files and the other stuff. In my case, using MinGW, it is located at
"C:\Apps\Qt\5.14.2\mingw73_64". If you are using the MSVC binaries,
select the corresponding directory, probably something like
I am trying to write video game reviews after I have finished a game
and I like to add some impressions in the form of screenshots to the
reviews. There is one problem though: sometimes it is impossible to
press the keyboard shortcut to capture a screenshot because the game
requires my full attention – and all my fingers. Therefore, I miss
out on a lot of action sequences. What does a programmer do in such a
situation? Write a tool that scratches the itch.
Optionals in Java have been around for some time now, basically since
the release of version 8. My other language of choice, C++, has
received this feature in version C++17. Since I am currently in the
process of writing some C++ code, I was curious how they were
implemented there. Optionals are trying to solve a problem that is
likely to plague any language. What shall a method or function return
if there is no value? Or shall it not return anything but instead
start crying like a petulant child and throw an exception?
As an introduction, let me dive a little bit into why we need
optionals (or do we?) and compare two different implementations of
this concept, one being java.util.Optional and the other C++
std::optional. I chose to compare these two language for several
I work with Java in my day job, so I have a good idea of how it
As mentioned, C++ is one of the languages I know quite well too.
The main reason: both optional implementations are add-on classes
rather than language features. More on that later.
Yes, you read that right. I have released a feature update for my WorkTracker tool. There was one little annoyance that I worked around by using copy and paste and since it was just a few key strokes, I didn’t bother. But in my renewed motivation to do some coding, I thought that it’s about time this issue goes to hell. And now it’s being grilled by Lucifer.Read More »
If you are a modern C++ developer, then you are probably using some kind of smart pointer implementation. The boost C++ libraries offer one possible solution (among many other useful features) and are generally held in high regards in the C++ community. With the latest C++11 standard, some of those ideas found their way into the standard library bundled with your C++ compiler. At some point, you very likely run into a situation where you need a shared_ptr of one of your classes, but only have a raw pointer or this available.
This is where enable_shared_from_this comes in. Boost and the standard C++ library provide this feature and they both have a very important prerequisite for this to work. Read More »
As a seasoned C++ developer I should’ve been aware of this which makes it a little bit embarrassing. But, since this issue has cost me several hours of searching through the Internet over the course of two or three days, I thought it might be worth sharing. Maybe somebody else is trying to be too smart or just doesn’t know better.
My little work-tracking tool has received some love recently and is now available in a more bug-free version. But not only that, I have made a foray into a foreign world and now support compilation on Linux and, to put the icing on the cake, even provide a deb package for Debian based distributions.
I have written about the performance of iterating directories before, in the context of Java and its switch from version 6 to 7 that brought with it the new Java NIO API. For whatever reason I felt the urge to do something similar again, but this time I wanted to compare two different approaches to recursively scanning a directory’s contents:
To make things more interesting, I implemented this in C++ using the Windows API and the Qt framework, in C# in combination with its buddy the .NET framework and, for good measure, I also threw in the old Java code from over a year ago.
Update (26.12.2014): I added additional data at the bottom of the article. Read More »
It has been around three months since the last release, June 22nd to be exact. Since then I have made some small changes along the way, but didn’t publish them because they haven’t been in the shape that I wanted them to be for a release, but still good and helpful enough for me to use them on a daily basis. The biggest new feature is an editor. Second comes the translation and around them gather a few improvements regarding usability.
It’s been a while since I have written something related to programming. Time to remedy that.
Just recently my interest for the C# language rose again and to get back up to speed with the fundamentals I swallowed all videos of an absolute beginners guide on Microsoft Virtual Academy. Something that has been touched briefly was LINQ and my initial thought was: how’s the performance of that compared to how I would usually write it in C++ – where my expertise is?
Mind you, I’m not comparing C# vs C++, but merely LINQ vs. old-school iteration. Let’s go and find out. Read More »
I have just released the first update to my work/time tracking tool WorkTracker, version 1.1.0. Included are a few visual enhancements, bugfixes, a new runtime and one feature I didn’t want to implement at first: resume a running task after application shutdown.Read More »