Posts on bool3max's blog

The importance of a good Table-of-Contents implementation

Sun, 13 Jul 2025 01:25:21 +0200

I’ve always found it invaluable to have a clear, complete and omnipresent overview of any text-based resource I’m absorbing. Having a “bird’s eye view” of all available information aleviates the feeling that I may have missed or skipped over something, and it helps me discern the way a section I’m reading at any given moment relates to the rest of the resource. It gives me a sense of security that I can’t really describe.

Modifying the Spotify client to persist tracklist View style between playlists and albums

Sat, 14 Jun 2025 18:49:37 +0200

The web and desktop versions of the Spotify client provide two distinct ways of displaying track lists when viewing a resource such as a playlist or an album:

Compact
List

They differ primarily in the amount of padding and spacing between the individual rows representing tracks, with the Compact mode also omitting the belonging album’s cover thumbnail to the left of each track:

Above you can see the difference between the two modes.

Threads and processes don't exist

Tue, 10 Dec 2024 21:07:04 +0200

On Linux, threads and processes don’t actually exist. Underneath all the abstractions, the kernel knows only of “tasks” - independent flows of execution, created using the clone(2) family of syscalls. The differences between what we call a “thread” and what we call a “process” lie in the flags argument of the clone syscall, which determines many kinds of properties of the eventually spawned task. The most notable of those is the sharing of virtual memory space, which is controlled by the CLONE_VM flag of the argument.

How is shell redirection implemented?

Mon, 17 Jul 2023 09:37:12 +0200

Shell redirection allows you to redirect a process’ standard streams to paths other than the controlling terminal. This post will focus on explaining how it is implemented by shells (such as bash). If you are unfamiliar with redirection and would like to familiarize yourself with the concept and syntax (as far as bash is concerned), then GNU Bash Reference Manual - Redirections is a good place to start.

The fundamentals

A running shell process maintains a set of open standard file descriptors for stdout (1), stderr(2) and stdin (0) that are tied to the controlling terminal. This can be observed by querying the /proc virtual filesystem. For example, in bash:

A HashMap speedup tale: The number of allocations matters

Wed, 14 Jun 2023 21:01:28 +0200

I recently wrote bhashmap - a C11 hash table implementation library. This post will document one of the latest optimizations, which is in hindsight extremely simple to understand and implement, but which resulted in a ~30% runtime speedup.

Background

Before talking about the optimization, let’s quickly get up to speed with how things worked before. I will focus only on the details relevant to this particular optimization.

At the core of every hash table implementation is a key-value pair, and here the case is no different: every such pair is represented by a HashPair struct:

How is time.sleep implemented in CPython?

Sat, 22 Apr 2023 21:25:29 +0200

I recently got curious as to how the time.sleep function from Python’s standard library was implemented by CPython - and as it turns out, it’s pretty easy to figure out.

All I had to do was strace a minimal example Python program that utlizies the function:

1strace python3 -c 'from time import sleep; sleep(0.5); print("Done!");' 2> out.txt

And sure enough, near the very end of strace’s output, we see the following system call:

A primer on the binary system: two's complement, IEEE-754 and more, explained

Sat, 18 Sep 2021 18:00:38 +0200

Modern 64-bit processors are capable of storing $2^{64}$ different values within their general-purpose registers. Each one of those possible values is simply a different combination of 64 sequential bits - and each one of those bits can, of course, exist in one of two states at a single point in time.

Given any number of bits $ N $, we can always conclude that the maximum number of different values representable using that particular bit count is always $ 2^N $.

How does 'man' actually display the pages?

Wed, 17 Feb 2021 13:44:42 +0100

When you normally execute, say man 3 printf, man simply does the job of looking up and fetching the particular manpage. The actual act of displaying it, is done by a pager.

The default pager that man uses, less, is in essence a simple TUI program that allows for easy navigation of a particular text buffer (scrolling, searching, etc… all using vi-like keybindings). It can output stylized text (bolds, underlines, etc…) which it does by default for manpages.

UTF-8

Thu, 03 Dec 2020 21:29:03 +0100

As of writing, Unicode contains 1,112,064 possible codepoints.

Actual codepoints range from 0 through 0x10FFFF though a part is reserved for backwards compatibility of other codecs with UTF-16, resulting in 1,112,064 actually available codepoints.

It’s important to note that not all (in fact most) codepoints are not characters. A common example is the Combining Diaeresis (e.g. ï) or the “double dot above” mark that, when rendered, simply appears above the adjecent previous character. In fact I can’t even paste it in neovim on its own, it simply appears above the previously typed character.

Iterators and Generators in Python3

Thu, 05 Nov 2020 00:32:02 +0100

Recently I needed a way to infinitely loop over a list in Python. Traditionally, this is extremely easy to do with simple indexing if the size of the list is known in advance. For example, an approach could look something like this:

1l = [1, 2, 3]
2i = 0
3
4while True:
5    print(l[i])
6    i += 1
7    if i == len(l):
8        i = 0

Eventually I settled on a an inbuilt approach using the itertools module from the standard library. Consequently the code became a lot cleaner:

Languages versus their implementations

Fri, 16 Oct 2020 14:23:54 +0200

Python is a programming language. It is nothing more but one large document of text and code examples (a standard) that describes exactly how the language is to behave. You can’t run it, download it, or execute it. That’s it, it’s just text.

The latest edition of it is up on the official Python website as the The Python Language Reference. As Python also consists of a standard library of functions, a document that describes how the modules and their respective functions are to behave is also readily available as The Python Standard Library.

Why I prefer fish over bash for scripting

Mon, 28 Sep 2020 15:45:48 +0200

Scripting with fish is simple. It is readable. You don’t need to have deep experience with it in order to understand the syntax.

Compared to bash, it feels intuitive.

Everything is a builtin

builtins are commands that you call from the shell, but unlike regular commands that execute external binaries and spawn new processes, they are built right into the shell (e.g. echo, math, set, count).

The core syntax of fish is very simple, and most all of the operations are done via calling builtins.

Understanding the ELF file structure

Sun, 09 Aug 2020 18:54:26 +0200

I recently took it upon myself to, at least at the surface level, understand how the ELF ("Executable and Linkable Format") works. In order to do that, I set out to create a tiny python3 module for parsing (meta-)data out of ELF files.

The result of that is p3elf, during the development of which I familiarized myself with ELF, binary IO in python, as well as setuptools and publishing python packages on PyPI.

Brief explanation of booting/GPT

Wed, 18 Sep 2019 17:42:03 +0200

This document serves as a quick reference to how UEFI and GPT work in regards to booting a modern system.

I will not cover BIOS/MBR in this document. I will acknowledge their existence and will compare them to their modern counterparts, but I feel that it is a waste of time to dig deeper into their inner workings. I will also not cover or mention the compatibility possibilites/issues of using UEFI/MBR or BIOS/GPT. Know that it is, in certain cases, possible, but that it is always a better idea to use either UEFI/GPT or BIOS/MBR. The ArchWiki and its numerous articles listed below cover the compatibility issues in more detail.

The 0xFFFFFFFF problem

Thu, 13 Sep 2018 02:51:42 +0200

This is a pretty old document that I wrote for myself back when I was first learning C, but the explanation is pretty good so I published it here for future reference. I hope to soon push a reference document that explains some tricky concepts and things from the C standard that are not so easy to remember off the top of the head (such as type conversion, declarations, storage durations, scopes, etc…)