I love gitk. It ships with git itself, which means every git installation has it, and it is still the fastest (gui) way I know to browse a repository’s history. Oftentimes I find myself doing code review for myself in gitk, just clicking through the commits and reading the diff. And every time I find something I want to change, I have to switch to a terminal, run git rebase -i <basecommit>, search for the right commit in the editor, change the entry from “pick” to “edit”, then open an editor for the file in question, find the correct spot, make the change, close the editor, git add my changes, and run git rebase --continue.

My choices are now basically to switch to a different tool that supports that kind of workflow, or I teach gitk how to run scripts. I chose the latter.

With my patch applied, you can define up to three commands each for the commit list and the diff display area. Commands are configured in a new “Commands” tab in the preferences dialog:

Each command has a name and a command template. Non-empty slots show up in the right-click context menu of the respective area:

Command templates support placeholder substitution and are executed via sh -c. The available placeholders are:

Exit code 0 means silent success. Exit code 42 displays the command’s output in a message box. Any other exit code displays an error. Append & to run the command asynchronously.

Find the pull request here.

Kitty is… “opinionated” in certain regards, but surprisingly standards conformant. The “kitten” program that bundles all the “built-in” functionality of this terminal emulator allows for amazing customizability. And yet, if you just start kitty, it looks, well, a bit rough to someone with two decades of Xfce4-Terminal socialization:

In this article I will list the configuration settings that I use to make kitty more familiar and maybe one or two other Xfce expats might find them useful, too.

Generating a new config

Kitty stores its config file at ~/.config/kitty/kitty.conf. This file does not exist by default. If you start kitty and press Ctrl+Shift+F2, an extensively annotated default config file will be generated and opened in your favorite text editor. Use that as your base.

Font size

Kitty defaults to 11pt. Maybe it’s just me and age taking a toll on my eyes, but I need at least 12pt to read comfortably:

font_size 12.0

Tab bar

I want my tab bar at the top, and looking more like actual tabs:

tab_bar_edge top
tab_bar_style slant

I also have taken a liking to having the tab bar always visible, even if there is only one tab:

tab_bar_min_tabs 1

And while we are at it, don’t overwrite the tab title by default:

shell_integration no-title

New tabs in current directory

map kitty_mod+enter launch --cwd=current --location=vsplit
map kitty_mod+t new_tab_with_cwd

Scroll bar

I want the scroll bar to be always visible, not only on mouse-over or scrolling, and I like it a little bit wider, say a full display cell instead of the default half:

scrollbar always
scrollbar_width 1

Next and previous tabs

Kitty defaults to Ctrl+Tab and Ctrl+Shift+Tab for cycling through tabs. I have built a lot of muscle-memory for Ctrl+PgUp and Ctrl+PgDn over the years, so let’s add these bindings:

map ctrl+page_down next_tab
map ctrl+page_up previous_tab

Sound

Pet peeve. I don’t want any “bing”, “boing”, “wush”, “shwich” or “dong” in my terminal. Draw a little bell emoji in the tab title if you need my attention:

bell_on_tab "🔔 "
enable_audio_bell no

Bonus: 🇩🇪-friendly window switching

Kitty comes with built-in window support, effectively tmux but with support from the terminal emulator, and it’s awesome. Only fly in the ointment: Cycling between the windows is mapped to Ctrl+[ and Ctrl+], which on a German keyboard are mapped behind AltGr+8 and AltGr+9, making the combo awkward. I have remapped this to Alt+Left and Alt+Right:

map alt+left previous_window
map alt+right next_window

struct Employee {
    int id;
    std::string name;
    ...
};

std::map<int, Employee> employees;

The key is the employee’s id. The value is the employee, which also contains the id. The id is stored twice: once as the map key, once inside the struct. Every insertion duplicates it, every lookup compares against the copy in the key, and the copy inside the value just sits there, taking up memory and begging to go out of sync.

This is one of those little code smells that irk me and taunt me, but this time I actually have a solution. C++14 came in to the rescue.

struct Employee {
    int id;
    std::string name;
    ...
};

bool operator<(const Employee& lhs, const Employee& rhs) {
    return lhs.id < rhs.id;
}

bool operator<(const Employee& lhs, const int& rhs) {
    return lhs.id < rhs;
}

bool operator<(const int& lhs, const Employee& rhs) {
    return lhs < rhs.id;
}


std::set<Employee, std::less<>> employees;

Make the container a std::set instead of a std::map. Using std::less<> enables heterogeneous lookup. No need to construct a full object, std::set::find() can then accept an argument of the key type.

int main() {
    employees.insert({1, "Neo" });
    employees.insert({2, "Trinity" });
    employees.insert({3, "Morpheus" });

    if (auto search = employees.find(1); search != employees.end())
        std::cout << "Found " << search->name << '\n';
    else
        std::cout << "Not found\n";

    return 0;
}

It replaces the manual workflow of staring at a diff, deciding “this hunk goes with commit 3, that one with commit 7,” and running git commit --fixup for each one. I have been doing that manually for years. And I really don’t want to talk about how often fixes have ended up in the wrong commit anyway, regardless of how careful I have been.

Curious what else I’ve been missing.

Man page for git absorb: git-absorb

Install with cargo install git-absorb or through your distribution’s package manager (Fedora: dnf install git-absorb, Debian: apt install git-absorb).

• Reading into a buffer that is bigger than 8 bytes (the size of one MSR register), does not read consecutive registers, but the same register over and over.

• Writing from a buffer that is bigger than 8 bytes does not write consecutive registers, but the same register over and over.

• Access to these files is locked behind file mode 0600 and CAP_SYS_RAWIO.

My attempt to let ordinary users read at least some MSR registers in 2023 failed, but I want to try again and make at least the reading and writing behavior less surprising. Patch is here.

Update, 2026-06-26:

Review is in. Need to drop the restriction to single writes. I can see the argument, but I don’t know if the overhead of multiple pwrite calls would really be so noticeable.

Update, 2026-06-26, but later:

Review for v2 is here as well, and there goes the restriction to the read function. Unsatisfactory. I hope at least the changes to the file comment go through so that the next developer who stumbles across this knows that there are users for this behavior.

Update, 2026-07-21:

They did!

During my studies, I dabbled a bit with FPGAs, nothing serious, but enough to make me curious. I recall the problems with the decidedly not open-source software required to program the boards, and the significant price of the boards. And here I was looking at an offer of less than 50 Euro for the board, with shipping and a few peripherals to toy around with still below a hundred.

Long story short, I am now the proud owner of such a device. But I have to say that “open source toolchain is supported” is technically true, but leaves out quite a bit about user friendliness, or the lack thereof. The tools are in the Debian repositories (or at least mostly are) but fail silently. Only the newest versions work correctly and you have to compile the toolchain from source to get everything working. For easy installation, I have assembled a Docker container that includes the necessary software and wrapper scripts for ease-of-use.

The official examples and demo projects for the Tang Primer 20k live here, but for a beginner like me, these are not well suited. If you are looking for examples that get you started and are maybe a bit more basic, look here: https://github.com/twied/TangPrimer-20K-example

Examples in this repository:

• LEDs: The ext board comes with six orange LEDS located at the right side of the board. They are labeled “5” to “0” from top to bottom. The example displays a simple static pattern.

• Clock: A simple example that flashes the LEDs once per second, in an alternating pattern.

• Switches: This example demonstrates how to read the status of the 5 switches located at the right side of the board. The LEDs display the result of some boolean functions.

• Buttons: This example shows how to read the status of the 5 buttons located at the left side of the board. Pushing S0 will turn LED 0 on, pushing S1 will turn the LED off.

• RGB LED: This example shows how to drive the RGB LED on the top left of the board by turning it yellow at medium intensity.

• Sound: This example shows how to use the audio jack on the top right of the board by playing a short sound file in a loop.

$ podman info --debug | grep graphDriverName
graphDriverName: vfs

If it says vfs, that is your problem. The vfs storage driver copies the entire container image on every start. No copy-on-write, no layer sharing, just a full deep copy. This apparently is the default you get, when installing podman on Debian with “recommended packages” disabled.

Install fuse-overlayfs, and run:

# WARNING! This deletes all containers, all images, all storage, everything!
$ podman system reset

Now the output changes to:

$ podman info --debug | grep graphDriverName
graphDriverName: overlay

Container startup went from 130 to 0.7 seconds, more than two orders of magnitude improvement.