A couple of years ago, after upgrading my Orange Pi Zero to Debian bookworm, I encountered several problems, and eventually, I migrated to Alpine Linux.

Everything worked well until a couple of weeks ago, when my system died. It stopped booting, and I could not read its microSD with my computer, either. I think the cause might be the power losses, which are more frequent than I would like at home.

I have a backup, but I do not remember if it contains the final configuration. Moreover, Alpine is a rolling distribution, so I would have needed to update and possibly reconfigure in any case, and I feared this would have taken much more time than I wanted to dedicate.

So, I gave Debian another chance, but it did not end well. It worked as expected for some days. Then, at a certain point, the system started becoming unreachable after a few hours (and, of course, it broke in the worst moments).

I even tried to set up a cronjob for daily reboots and a watchdog, but I still had the problem.

At this point, I thought that maybe the Orange Pi Zero support in bookworm’s kernel (6.1.x) was not mature enough, and I hoped a newer kernel was more stable. Debian trixie is becoming the next stable this year, so I just anticipated the upgrade… and it worked! (At least for now 😄).

I kept the scheduled reboot, but I think the system would keep working also without it.

My only problem was that the upgrade removed my changes to the kernel command line in /boot/boot.cmd, so I had to restore them manually and re-create /boot/boot.scr.

For my work, sometimes I send contributions to Firefox.

Mozilla has existed for a long time, and this is definitely visible in the integration of the development tools they use.

However, some of them are kinda unique, particularly their SCM: Mercurial.

Today, open source is almost a git monoculture, and it is the versioning system I have used most of the time. Therefore, I got used to forks, PRs/MRs, and so on. But Hg does not have anything of this.

Theoretically, Mozilla also supports git, with a bridge called git-cinnabar. However, I always had trouble when trying to use it. Eventually, I learned a few tricks about Mercurial.

The feature I initially missed the most was branching… It took me an embarrassing amount of time to understand that I could just checkout (err, update -r) existing revisions and add commits to create new heads.

Then, you can use hg heads to see all the heads you have created.

You can also assign names like you would do with git branches with bookmarks, but I do not use them often.

Part of my confusion is also due to hg log listing in chronological order (I believe, but I am still unsure). It starts from the most recent commit it knows and then shows commits that are not ancestors of the one checked out.

Showing the graph with the -G option makes the output a bit clearer for me.

Anyway, Mozilla decided to move Firefox to git as well over one year ago, so all of this will not be needed sooner rather than later.

Recently, I wanted to install a legacy OS in a virtual machine with QEMU.

However, for several reasons, I did not want it to be able to access the Internet but still be able to access some services on my host.

I had already done something similar in the past with a tap interface, but it was not very convenient, as you need to bring your own DHCP server or use manual configuration.

So, by reading the fine manual, I found an option I had not heard about before: restricted=yes on the user network mode.

It makes QEMU create a virtual network, with the usual DHCP server and connection to the host, but without Internet access.

In addition, it is possible to specify various guestfwd options.

Sadly, the forward mode opens only one connection when the machine boots. Therefore, if you want to forward every new connection, you will have to go through netcat or a similar program. For example, I used this option to redirect connections to 10.0.2.100 to an HTTP server I created with Python:

-nic 'user,model=virtio-net-pci,restrict=yes,guestfwd=tcp:10.0.2.100:80-cmd:netcat 127.0.0.1 8000'

And that was enough for me to pass a few files without using Samba or swapping isos.

Recently, I had to check a legacy email address we used at home until a few years ago.

We almost stopped using it, but some services are still tied to it. The result is that whenever I need to check it, I find tons of spam, and the web interface is kinda bad, so it takes ages to delete all of it.

Some months ago, I learned to interact with IMAP from Python when I wrote a script to download and back up email accounts.

So, I modified it to output a CSV with all the senders and subjects of the emails in the mailbox. The scripts left a column empty to mark the emails that should be deleted with an x.

Then, I wrote another script to read the modified changes and to move the marked emails to the trash for a final review before emptying it.

Recently, I found myself in the same situation again, but I did not keep these scripts, so I had to write a new one.

It did not take much, but since it might be helpful to someone (at least the future me), I decided to share it here.

It takes the parameters to connect to the IMAP server on the command line. Then, it takes the action (write-csv to create the CSV with the list of emails, or read-csv to read it to send the changes to the server), and finally the name of the CSV file.

The script is released in the public domain, and, as always, it comes without any warranty.

Occasionally, I still work with my Intel RealSense, on my RGBD toolbox, and affine topics.

Recently, I decided to allow multiple formats for the color images (initially, I had hardcoded them to JPEG only).

Therefore, I had to modify my data structures to work with pairs of paths instead of their common stems.

The UI to add new frames to the scene lists all the valid frames once and puts them into an ordered std::set, now keyed on the path pair.

With my previous assumption on fixed formats, I could do lookups on the set to quickly check if a provided stem was valid.

After the changes, this involved a heterogeneous comparison, i.e., a comparison of different types.

The trivial way to do this is a linear search, e.g., with std::find and a lambda or a range-based for.

However, this seemed a frequent case to me, and I was curious to see if there was a way to still take advantage of the optimized algorithms provided by the containers.

Indeed, there is! But it was added only since C++14.

After implementing bool operator<(const Other &, const Key &), you can pass std::less<> as a comparator to your container instead of the default std::less<Key>.

That is a particular template specialization that was developed for this purpose. It contains an is_transparent type that enables the templated version of some methods in STL containers.

This stack overflow answer contains many details. A TL; DR is that this implementation avoids unwanted conversions that could have undesired effects (e.g., the continuous creation of temporary objects from literals).