Patrick Van der Spiegel's Notes

Maasmarathon

Sun, 03 May 2026 00:00:00 +0000

Distance 42.99 km

Moving time 3:59:09

Elevation 273 m

Spent the weekend at Blegny for the 27th Maasmarathon in Visé. Took the opportunity to walk over the recently opened passerelle de Caster near Kanne, a suspension bridge at 55 metres height over the Albert Canal.

Took the 15-minute trip from Visé to Maastricht in the Netherlands with the Drielandentrein. Visited a bookshop in a church, went to the “Porous Grounds, Sacred Codes” exhibition at Marres, House for Contemporary Culture, and stood at the Drielandenpunt in Vaals where the borders of Belgium, the Netherlands, and Germany intersect.

For the marathon itself, I finally managed to run one under four hours. Couldn’t have done it without the pacer! My previous chip times were:

Race	Year	Chip time
Stockholm Marathon	2024	05:12:03
In Flanders Fields Marathon	2024	04:11:00
European Running Championships	2025	04:12:47

I’ll limit myself to one marathon per year. My next marathon would be the European Running Championships 2027 in Belgrade.

Anagram hikes

Sat, 21 Mar 2026 00:00:00 +0000

bpost has a postal code validation tool, providing a spreadsheet of postal codes with names of Belgian communes and their deelgemeenten. We can convert the spreadsheet to a CSV file using ssconvert, and filter out all special postal codesSinterklaas has his own postal code: 612, for 6th of December. (which are not linked to a commune, but to large public institutions and broadcasters that get their own postal codePostal codes in Belgium – Wikipedia) with xan.

ssconvert zipcodes_num_nl_2025.xls postal.csv
xan head postal.csv | xan view

Displaying 5 cols from 10 rows of <stdin>
┌───┬──────────┬────────────────┬──────────────┬────────────────┬───────────┐
│ - │ Postcode │ Plaatsnaam │ Deelgemeente │ Hoofdgemeente │ Provincie │
├───┼──────────┼────────────────┼──────────────┼────────────────┼───────────┤
│ 0 │ 612 │ Sinterklaas │ <empty> │ Sinterklaas │ <empty> │
│ 1 │ 1000 │ Brussel │ Neen │ BRUSSEL │ BRUSSEL │
│ 2 │ 1005 │ Verenigde Ver… │ <empty> │ Verenigde Ver… │ <empty> │
│ 3 │ 1006 │ Raad van de V… │ <empty> │ Raad van de V… │ <empty> │
│ 4 │ 1007 │ Assemblée de … │ <empty> │ Assemblée de … │ <empty> │
│ 5 │ 1008 │ Kamer van Vol… │ <empty> │ Kamer van Vol… │ <empty> │
│ 6 │ 1009 │ Belgische Sen… │ <empty> │ Belgische Sen… │ <empty> │
│ 7 │ 1011 │ Vlaams Parlem… │ <empty> │ Vlaams Parlem… │ <empty> │
│ 8 │ 1012 │ Parlement de … │ <empty> │ Parlement de … │ <empty> │
│ 9 │ 1020 │ Laken │ Ja │ BRUSSEL │ BRUSSEL │
└───┴──────────┴────────────────┴──────────────┴────────────────┴───────────┘

Filtering out these special cases:

Displaying 5 cols from 10 rows of <stdin>
┌───┬──────────┬─────────────────────┬───────────┬─────────────────────┬───────────┐
│ - │ Postcode │ Plaatsnaam │ Deelgeme… │ Hoofdgemeente │ Provincie │
├───┼──────────┼─────────────────────┼───────────┼─────────────────────┼───────────┤
│ 0 │ 1000 │ Brussel │ Neen │ BRUSSEL │ BRUSSEL │
│ 1 │ 1020 │ Laken │ Ja │ BRUSSEL │ BRUSSEL │
│ 2 │ 1030 │ Schaarbeek │ Neen │ SCHAARBEEK │ BRUSSEL │
│ 3 │ 1040 │ Etterbeek │ Neen │ ETTERBEEK │ BRUSSEL │
│ 4 │ 1050 │ Elsene │ Neen │ ELSENE │ BRUSSEL │
│ 5 │ 1060 │ Sint-Gillis │ Neen │ SINT-GILLIS │ BRUSSEL │
│ 6 │ 1070 │ Anderlecht │ Neen │ ANDERLECHT │ BRUSSEL │
│ 7 │ 1080 │ Sint-Jans-Molenbeek │ Neen │ SINT-JANS-MOLENBEEK │ BRUSSEL │
│ 8 │ 1081 │ Koekelberg │ Neen │ KOEKELBERG │ BRUSSEL │
│ 9 │ 1082 │ Sint-Agatha-Berchem │ Neen │ SINT-AGATHA-BERCHEM │ BRUSSEL │
└───┴──────────┴─────────────────────┴───────────┴─────────────────────┴───────────┘

We are interested in both the names of hoofdgemeenten and deelgemeenten in lowercase. We put both of these in one column using xan unpivot 1,3, which puts all values in a column named value. We now have some duplicates in this column, which is why we also need dedup before writing these to a towns.txt file.

xan filter "!eq(Deelgemeente, '')" postal.csv \
	| xan transform 1,3 'lower(_)' \
	| xan unpivot 1,3 \
	| xan select value \
	| xan dedup > towns.txt

We end up with a list of 2733 names:

xan head towns.txt | xan view

Displaying 1 col from 10 rows of <stdin>
┌───┬─────────────────────┐
│ - │ value │
├───┼─────────────────────┤
│ 0 │ brussel │
│ 1 │ laken │
│ 2 │ schaarbeek │
│ 3 │ etterbeek │
│ 4 │ elsene │
│ 5 │ sint-gillis │
│ 6 │ anderlecht │
│ 7 │ sint-jans-molenbeek │
│ 8 │ koekelberg │
│ 9 │ sint-agatha-berchem │
└───┴─────────────────────┘

With the alphabetic map of these names, we get 18 anagram town pairs for which we plan hiking routes using the openrouteservice API.

rosée ⟷ sorée
idegem ⟷ diegem
olen ⟷ olne
tiegem ⟷ itegem
seraing ⟷ ragnies
herent ⟷ herten
erpe ⟷ peer
laken ⟷ alken
meerbeke ⟷ meerbeek
mere ⟷ meer
mollem ⟷ lommel
herve ⟷ hever
virelles ⟷ serville
veulen ⟷ leuven
borsbeke ⟷ borsbeek
berloz ⟷ borlez
lembeke ⟷ lembeek
edingen ⟷ gedinne

< 1000 kilometres in 2025

Wed, 07 Jan 2026 00:00:00 +0000

See 2024; will post "> 1000 kilometres in 2026" next year.

1000 kilometres in 2024

Sat, 04 Jan 2025 00:00:00 +0000

intervals.icu API and jq:

BASE_URL="https://intervals.icu/api/v1/athlete"
OLDEST="2024-01-01"
NEWEST="2024-12-31"

# Fetch activities
activities=$(curl -s -u API_KEY:$API_KEY \
 "$BASE_URL/$INTERVALS_UID/activities?oldest=$OLDEST&newest=$NEWEST")

# CSV header
echo "date,cumulative_distance"

# Initialise cumulative distance and iterate through each date
cumulative_distance=0
current_date=$(date -I -d "$OLDEST")
end_date=$(date -I -d "$NEWEST + 1 day")

while [ $current_date != $end_date ]; do
 # Calculate total distance for the current day
 day_distance=$(echo "$activities" | \
 jq --arg date "$current_date" '
 map(select(.type == "Run" and 
 (.start_date_local | startswith($date)))) | 
 map(.distance) | 
 add // 0') # return day distance (or return 0 if false or null)

 # Add day distance to cumulative distance
 cumulative_distance=$(echo "[$cumulative_distance, $day_distance]" | jq 'add')
 
 # Date and cumulative distance up until current date
 echo "$current_date,$cumulative_distance"
 
 # Move to the next day
 current_date=$(date -I -d "$current_date + 1 day")
done

date,cumulative_distance
2024-01-01,0
2024-01-02,6919
2024-01-03,6919
2024-01-04,10034
2024-01-05,10034
...
2024-12-27,958647.54
2024-12-28,973656.54
2024-12-29,973656.54
2024-12-30,980075.54
2024-12-31,1000088.54

gnuplot:

set terminal pngcairo size 1024,768 font "iA Writer Quattro V"
set output 'cumulative_distance_graph.png'

# Set data file separator and time-related settings
set datafile separator ","
set xdata time
set timefmt "%Y-%m-%d"
set format x "%B"
set ylabel "Cumulative Running Distance in 2024"
set grid

# Customize axis and range
set xtics rotate by -45
set yrange [0:1150]
set xrange ['2024-01-01':*]

# Set margins
set lmargin 16
set rmargin 10
set tmargin 5
set bmargin 6

# Mark specific races with arrows and labels
set arrow from '2024-06-01',0 to '2024-06-01',1150 nohead lw 1 dashtype 3 linecolor "gray30" # Stockholm marathon
set label "🇸🇪" at '2024-06-03',950

set arrow from '2024-09-15',0 to '2024-09-15',1150 nohead lw 1 dashtype 3 linecolor "gray30" # In Flanders Fields marathon
set label "🇧🇪" at '2024-09-17',950

# Plot cumulative distance and 1000 km goal with markers and styles
plot "cumulative_distance.csv" using 1:($2/1000) with lines title "Cumulative Distance (km)" lw 2 linecolor rgb "orange-red", \
 0 with lines title "Marathons" lw 1 dashtype 3 linecolor "black", \
 1000 with lines notitle "1000 km" lw 1 dashtype 2 linecolor "black"

Common Favourite Films on Letterboxd

Thu, 26 Dec 2024 00:00:00 +0000

Letterboxd allows users to list up to four favourite films, but there’s no built-in way to find people with similar tastes. To solve this, I developed a script to scrape ‘fans’ of specific films and identify overlapping favourites.

My favourite films on Letterboxd

Scraping Fans

As there is no public Letterboxd APII requested access to the Letterboxd API beta in 2016, but never received a response. but I still want to find people with similar movie tastes, I wrote a script that takes a Letterboxd movie identifier as an argument and scrapes the list of users who have listed this movie as one of their four favourites (also called “fans” on Letterboxd). This script curls every fan page of the given movie, extracting user identifiers through a regex with grep, and appending them to a CSV file.

#!/bin/sh

movie=$1
page=1

while :; do
 fans=$(curl --silent "https://letterboxd.com/film/$movie/fans/page/$page/" | \
 grep -Po '(?<=a href="/)[^"]+(?=/\" class=\"name\")')
 [ -z "$fans" ] && break
 echo "$fans" >> "${movie}_fans.csv"
 page=$((page + 1))
done

As a test, we can look at the “The Innocents”, which currently has 88 fans. "./letterboxdFans.sh the-innocents-2021" produces a CSV named "the-innocents-2021_fans.csv" in the same folder. Using the fish shell, we check the number of entries by counting newlines in the CSV with cat and count.

$ cat the-innocents-2021_fans.csv | count
88

Looking at some popular films (like Parasite, for example) shows that we can see at most 6.4k fans even though there are 102k of them in this specific case, however. As there are 25 fans displayed per page, and we can only scrape 6.4k of them, this means that the fan pages are capped at page 256. Manually confirming this indeed shows that there are at most 256 pages of alphabetically ordered fans per film.

Finding Similar Profiles

After scraping ~~all~~ at most 6.4k fans of each of my four favourite films and putting the resulting CSVs in a separate folder, we can find profiles that have at least two favourite films in common by looking for duplicate entries:

$ ls letterboxd_fans/
good-time_fans.csv 
paterson_fans.csv 
perfect-days-2023_fans.csv 
uncut-gems_fans.csv

$ cat letterboxd_fans/* | sort > merged.csv
$ uniq -c merged.csv | sort -nr | head -n 5
 2 mandypixel
 2 malcolmconger
 2 louistoth
 2 loshmy
 2 ln42

Automatically Following Profiles

I attempted to automatically follow profiles that share at least two favourite films using Selenium, but only got as far as automatically visiting every profile with shared favourite films.

Current issues include not being able to use an existing Firefox profile that is logged into my Letterboxd account to Selenium, and not being able to automatically click on the Follow button.

As this is just a quick one-time project, I manually logged in using the browser that pops up after starting my script before automatically cycling through profiles from the merged.csv list and manually clicking the follow button before the next profile page loads. This allowed me to quickly follow a couple of profiles with common favourite movies.

llm + Espanso: Clipboard Summaries

Mon, 09 Sep 2024 00:00:00 +0000

I recently wrote an Espanso trigger named :llm(⋯) that pipes the contents of my clipboard to Simon Willison’s llm CLI tool and expands the trigger to llm’s output in a custom Obsidian callout. This regex trigger expects a keyword (like summarise, simplify, or translate) between its parenthesis, and transforms this keyword to a prompt that summarises, simplifies, or translates whatever text I current have within my clipboard.

After frequent use of this trigger, I noticed that I mostly use :llm(summarise). To simplify my workflow, I decided to transfer summarisation to a dedicated :summary trigger so that I don’t have to rely on providing and capturing keywords using regex:

- trigger: ":summary"
 replace: "> [!llm] _\"{{title}}\"_\n> {{summary}}"
 vars:
 - name: clipboard
 type: clipboard
 - name: summary
 type: shell
 params:
 cmd: "echo $ESPANSO_CLIPBOARD | llm -m 'gpt-4o' -s
 \ 'Summarise the provided text into a concise UK English paragraph. 
 \ Ensure the summary captures essential information.'"
 - name: title
 type: shell
 params:
 cmd: "echo $ESPANSO_SUMMARY | llm -m 'gpt-4o-mini' -s
 \ 'Generate a short one-sentence title that accurately reflects
 \ the main idea of the summary. Use UK English.'"

Can GPT Boggle?

Tue, 27 Aug 2024 00:00:00 +0000

During the programming and writing of “Automating Boggle”, I remember being surprised that popular AI models (like GPT-4) — capable of many remarkable tasks — couldn’t do something so “trivial” as reading rotated dice. I regularly retry using the OpenAI API to recognise the labels on these dice, but the models always fail to do so (and they often fail spectacularly). The prompt I use is the following:

"Given an image of a 4x4 grid of Boggle dice, extract and return the 16 letters from the grid, in a continuous string from top left to bottom right, left-to-right across each row. Account for any rotations of the letters. The output should be the correct sequence of letters as a continuous string, without any additional text, newlines, and formatting."

It often happens that I get more than 16 letters in return, most of them not even present on the board. If we look at the OpenAI API documentation, under the section of Limitations, we see:

Rotation: The model may misinterpret rotated / upside-down text or images.

Instead of manually calling the API once in a while to see if an updated version of a vision model can complete the task, I plan to write a GitHub Actions workflow that regularly calls the API and compares the output to the expected solution, printing the results on this website. Guess this will be my AI model benchmark: how long before these models can read rotated dice from an image and the instructions from the prompt above?

git mailmap

Mon, 26 Aug 2024 00:00:00 +0000

I work on my Git repositories from different machines, which separates my contributions over different Git identities. Looking at all developers that contributed to one of my project’s repository, we get the following:

(base) pvdsp@laptop:~/git/⋯$ git shortlog -sne
 71 Patrick Van der Spiegel <pvdsp@⋯.be>
 58 Patrick Van der Spiegel <patrick@⋯.com>
 ⋯

Adding a .mailmap file to the root directory of the repository — following the Proper Name <proper@email.xx> <commit@email.xx> structure — fixes this issue:

Patrick Van der Spiegel <pvdsp@⋯.be> <patrick@⋯.com>

(base) pvdsp@laptop:~/git/⋯$ git shortlog -sne
 129 Patrick Van der Spiegel <pvdsp@⋯.be>

Joining Mastodon

Sun, 25 Aug 2024 00:00:00 +0000

After years of lurking on Twitter — barely contributing to conversations on the platform, and only using it to read tweets from creators I follow — I am trying out Mastodon for a while. I planned to do this a while ago: most people I follow on Twitter also use or cross-post to Mastodon, and it makes sense to use non-commercial alternatives where possible.

Reading blog posts through my RSS reader is excellent for keeping up with news related to my interests, but I sometimes miss some interaction and discussion on these posts. I hope to find this interaction through Mastodon, as not every blog supports Webmentions (and I do not yet have it fully implemented either).

For now, I have:

Manually searched and followed people of which I read their blogs
Added a link to my Mastodon profile on my main page (including ⁂)
Verified my domain by adding <link href="https://c.im/@pvdsp" rel="me"> to the <head> of my pages

I looked into using my custom domain for Mastodon so that I could use @patrick@vanderspie.gl as my username, but I will postpone this as it involves setting up your own Mastodon server or using a managed host (and I feel like using a custom domain is not worth yet another subscription).

I’ve heard good things about Mastodon so far, so I look forward to seeing if it is a better Twitter alternative!

CSS filter posts by category

Sat, 24 Aug 2024 00:00:00 +0000

As I also plan to upload non-technical posts and notes on my website, I added the ability to filter content based on categories. Trying to avoid another Javascript solution, I remembered the CSS :has selector (which I read about in a blog post from Ryan Mulligan’s website).

I based my solution on his examples, tailoring it to the classes available in my Hugo theme. First, I added a partial with a fieldset and included it in the HTML template used for lists. For now, the categories are hard-coded, as I don’t plan on adding more in the future:

<fieldset>
 <legend>Filter by category:</legend>

 <div>
 <input type="radio" id="all" name="filter" value="all" checked />
 <label for="all">Show all</label>
 </div>

 <div>
 <input type="radio" id="tech" name="filter" value="tech" />
 <label for="tech">Only technical</label>
 </div>

 <div>
 <input type="radio" id="nontech" name="filter" value="nontech" />
 <label for="nontech">Only non-technical</label>
 </div>
</fieldset>

Next, I added the following to my css:

fieldset {
 opacity: 75%; 
 font-size: 0.75em;
 border: dotted;
 border-width: 1px;
}

body:has([name="filter"][value="tech"]:checked)
 .post-line:not([category="tech"]) {
 display: none;
}

body:has([name="filter"][value="nontech"]:checked)
 .post-line:not([category="nontech"]) {
 display: none;
}

Finally, to make the filters work, I added a category to every post or note in Hugo:

---
title: "CSS filter posts by category"
date: "2024-08-24"
⋯
category: "tech"
---

and included this category in the partial for post entries:

<div class="post-line" category="{{ .Params.category }}">
	⋯
</div>

Python packaging in Rust

Fri, 23 Aug 2024 00:00:00 +0000

Thanks to a blog post by Simon Willison, I learned about the open-source Python tooling by Astral. Coincidentally, I started looking into the Rust programming language a few days ago and was pleasantly surprised by Cargo.

uv — which is a Python package and project manager written in Rust — is a kind of “Cargo, for Python”. Looking at the highlights in uv’s README.md file, the tool sounds promising, and I fully intend to try it out soon. The demonstrations on their blog post are convincing, especially uvx and uv run:

With uv run, you don’t have to think about activating virtual environments, managing dependencies, or keeping your project up-to-date. It just works.

Astral - uv: Unified Python packaging

and, more importantly:

(⋯) it also adds features that are essential to local development but not covered by the standards, like relative paths and editable dependencies.

Astral - uv: Unified Python packaging

Astral also provides a Python linter and code formatter written in Rust, named ruff. I’m currently not using a dedicated linter; I’m just relying on my IDE and its built-in checks, but I might try adding ruff to my workflow.

Tracking tasks in Obsidian

Thu, 22 Aug 2024 00:00:00 +0000

A couple of days ago, I made a simple addition to my Pomodoro timer. To better keep track of work done in a given day, I edited my daily notes template of my Obsidian journal to include a table with a row for each pomodoro interval, explaining what I did during that interval:

---
type: research journal
pomodori: 
---
# Tasks of the day
| Hours | Task |
| ----- | ----- |
# Topics
- 

# Ideas and Insights
-

I now keep track of when a new interval starts, and write a new row after each interval ends. This row includes:

The start and end time of the interval
Space for a one-sentence summary of what I did during that interval

START_TIME=$(date +%H:%M)
ENTRY="$JOURNAL/$(date +%Y-%m-%d) Research Journal.md"
⋯

NEW_ROW="| $START_TIME — $(date +%H:%M) | ⋯ |"
sed -i "s/# Topics/$NEW_ROW\n# Topics/" "$ENTRY"

A short and quick addition, but I’ve noticed that it helps me keep focused on one specific task during each 25-minute interval, for now. As an example:

Hours	Task
09:02 — 09:27	Literature review on `[[Complex Systems\|DES]]` `#phd`
09:34 — 09:48	Reading `[[🔴 (Zimmermann, 2008)]]` `#phd`
10:48 — 11:16	Reading paper draft `#paper`
⋯	⋯

Learning Rust

Wed, 21 Aug 2024 00:00:00 +0000

I started experimenting with the Rust programming language by reading “the book”, trying some basic things and loosely following along with the examples. Although I’ve only gone through the first three chapters — stopping after the common programming concepts and leaving the idea of ownership for later — I’m still planning to write down what I found interesting about the language compared to the ones I use more often (mainly Python and Julia).

Nothing interesting will be written here for anyone familiar with Rust, but I’m growing fond of the idea behind “blogumentation” for self-documentation. In this case, writing things down that I found interesting will help me remember them:

Terminating statements with `;`

Like multiple other languages, Rust uses the semicolon after statements. I wondered why this is so often the convention, and found a blog post by Nicole Tietz speculating why that is the case.

Cargo and initialising Git repositories

Using Cargo — which also initialises a new Git repository by default and creates the project structure when you begin a new project — seems like a great workflow.

Cargo expects your source files to live inside the src directory. The top-level project directory is just for README files, license information, configuration files, and anything else not related to your code. Using Cargo helps you organise your projects. There’s a place for everything, and everything is in its place.

The Rust Programming Language

In general, I think it’s helpful that it initialises and enforces this organisation. I tend to ignore conventions when quickly whipping something up in Python, which gets messy quickly.

Shadowing of immutable variables

Variables are immutable by default, but I was initially confused as to why you would allow shadowing for immutable variables. I did not immediately see any scenario where it would make sense to shadow an immutable variable. This will probably make more sense once I see some examples in practice. Another thing about shadowing that I found a bit weird is the example below:

let spaces = " ";
let spaces = spaces.len();

The first spaces variable is a string type and the second spaces variable is a number type. Shadowing thus spares us from having to come up with different names, such as spaces_str and spaces_num; instead, we can reuse the simpler spaces name.

The Rust Programming Language

This feels like a fast way for things to get messy, shadowing the same variable in different scopes but changing the type (and thus the meaning) of the variable, but keeping the name. spaces_str and spaces_num don’t sound so bad to me, as the names at least convey meaning.

Visual separator for integer literals

Number literals can also use _ as a visual separator to make the number easier to read, such as 1_000, which will have the same value as if you had specified 1000.

The Rust Programming Language

Through looking up other languages that provide a visual separator for integer literals, I stumbled upon this GitHub issue, which contains some interesting discussion on separators.

Other things that I like so far, at first glance

A lot of these might seem very standard, but as Python is my daily driver, it’s nice to try a language that has:

Integer division truncating toward zero to the nearest integer:

let truncated = -5 / 3; // Results in -1

The terminology “destructuring” for breaking up a single tuple into parts (which Python also has, but first time that I encounter this terminology):

let tup = (500, 6.4, 1);
let (x, y, z) = tup;

The distinction between arrays and vectors, and the initialisation of an array using this notation:

let a = [3; 5]; // same as writing let a = [3, 3, 3, 3, 3];

The fact that you must declare the type of each parameter in function signatures:

fn main() {
 print_labeled_measurement(5, 'h');
}

fn print_labeled_measurement(value: i32, unit_label: char) {
 println!("The measurement is: {value}{unit_label}");
}

The distinction between acting and returning through statements and expressions (and that expressions don’t have ending semicolons). I already see myself making mistakes by turning expressions into statements — not letting it return a value — by accidentally adding a semicolon. Luckily, the thrown errors are very readable, so far:

$ cargo run
 Compiling functions v0.1.0 (file:///projects/functions)
error: expected expression, found `let` statement
 --> src/main.rs:2:14
 |
2 | let x = (let y = 6);
 | ^^^
 |
 = note: only supported directly in conditions of `if` and `while` expressions

The fact that conditions must explicitly be booleans:

$ cargo run
 Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: mismatched types
 --> src/main.rs:4:8
 |
4 | if number {
 | ^^^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` (bin "branches") due to 1 previous error

One-line assignment using if, but enforcing that the result of each arm must be of the same type:

let number = if condition { 5 } else { 6 };

The loop keyword and loop labels (probably used sparingly as there are while and for keywords as well):

fn main() {
 loop {
 println!("again!");
 }
}

Looking forward to learning more about Rust!

Visualising Belgian roads

Tue, 20 Aug 2024 00:00:00 +0000

When exploring Overture data earlier this month, I stumbled upon “All Streets” by Ben Fry. I loved the visualisation and wondered how I could reproduce it for other countries. Looking at Ben Fry’s writing archive, he briefly discussed his work in a blog post from 2008:

Nothing particularly genius about this piece—it’s mostly just a matter of collecting the data and creating the image. But it’s one of those cases where even in a (relatively) raw format, the data itself is quite striking.

Ben Fry

“Collecting the data and creating the image”: as easy as drawing an owl. Luckily, the rest of the blog post reveals a bit more of the process — but sadly doesn’t really help me in reproducing it for other countries.

After a bit of Googling, I found great work by Andrei Kashcha: city-roads, which allows you to render roads in any area using data from OpenStreetMap, which I used for the image at the top of this note. I plan to dive into the open-sourced code of city-roads, and I might try to make something similar from scratch using Overture (just to learn how it works, as inspired by a comment on lobste.rs):

You should make a toy version of every major tool you use, if you can find the time and energy to do so. It’s a great way to understand the constraints that go into the tools you use and the limits of their capabilities.

lobste.rs comment

I want to do something similar as city-roads, but expand it by combining it with Overture Places data. Possibilities for visualisation include heatmaps for distance from road segments to specific types of places (like the nearest train station or bus stop, for example), or create a Chronotrains-style alternative on a Belgian map, using open data from NMBS, De Lijn, and TEC.

Displaying tags in Hugo

Mon, 19 Aug 2024 00:00:00 +0000

As I plan to write about a variety of different topics on this website, I decided to add tags to the properties of all my posts and notes so far:

---
title: "Displaying tags in Hugo"
date: "2024-08-19"
tags: ["hugo"]
⋯
---

Tags were already available in the Hugo theme that I am currently using, but I did not like the way they were displayed. I edited partials/post-entry.html so there’s a loop over every tag of a post, displaying them as a comma-delimited list next to the post or note’s title:

<div class="post-line">
 {{ $dateFormat := "2 Jan 2006"}}
 {{ with .Site.Params.listDateFormat }}
 {{ $dateFormat = .}}
 {{ end }}

 <p class="line-date">{{ .Date.Format $dateFormat }} </p>

 <span>
 <a href="{{ .RelPermalink }}">
 {{- .Title -}}
 </a>

 {{ if .Site.Params.listSummaries }}
 <span class="post-tags">
 {{- range $index, $tag := .Params.tags -}}
 {{ if $index }}, {{ end }}<a href="{{ printf "/tags/%s/" $tag | urlize }}">#{{ $tag }}</a>
 {{- end -}}
 </span>

 <div class="line-summary"> {{ .Description | markdownify }} </div>
 {{ end }}
 </span>
</div>

.post-tags {
 font-size: 0.7em;
 opacity: 50%;
 vertical-align: baseline;
}

Clicking on the link of the tag brings you to a list of all posts or note’s with the same tag.

Using data sources in Hugo

Sun, 18 Aug 2024 00:00:00 +0000

Until now, I have been storing different variables as site parameters in my Hugo website’s hugo.toml file. A regularly triggered GitHub Actions workflow updates these variables by using various APIs to check for any changes. If changes are detected, the workflow updates the hugo.toml file with the new values (replacing the old ones using sed) and pushes the changes to my website’s GitHub repository. There, another GitHub Workflow builds my Hugo website and deploys it to GitHub Pages.

As I start tracking more variables than originally planned, it makes sense to store them the proper way: using data sources in Hugo. My plan is to keep a yaml file in my Hugo website’s data directory, which will store all variables that I want to display on my website. The rest of the workflow should remain unchanged, but this approach should separate these variables from actual site parameters.

running_distance: 720851.2999999999
running_cp: 3.5694862545565007
writing_streak: 12
best_writing_streak: 12
best_writing_streak_date: "2024-08-19"
tr_value: 6150.468645723648
tr_rank: b

I’m planning to write a decent and complete post explaining which APIs I use, the variables that I store (and plan to store in the future), and how these GitHub Workflows work. I currently keep track of the following variables:

Variable	Value
Longest writing streak	20 days \| Achieved on Aug 27, 2024
Current writing streak	0 days \| Updated on May 10, 2026
Running Critical Power	3.490 W/kg
Distance ran this year	418.2 km
TETR.IO’s TETRA LEAGUE	11126.88 TR ()

Displaying TETR.IO TR on website

Sat, 17 Aug 2024 00:00:00 +0000

TETR.IO’s started its new season yesterday. A couple of days ago, I planned to scrape my TETR.IO profile to display the change in my TR over time. The game’s patch notes include the feature that I was missing in the game’s previous season, however:

You can now see your TR change over time on the TETRA CHANNEL site.

TETR.IO Patch Notes

Additionally, if I still want to include my TR over time on my website, scraping isn’t necessary at all: the patch notes mention that the game provides an API. Simply using curl and jq gives me all the data I need:

curl https://ch.tetr.io/api/users/geuze/summaries/league | jq '.data | .tr'

I store this data as a site parameter in my hugo.toml file:

TETRIO_TR = 3090.2731291544947
TETRIO_RANK = "c+"

Now, I can use it in a Hugo shortcode:

<span>
	{{ printf "%.2f" .Site.Params.TETRIO_TR }} TR
	(<img class="tr_rank" 
		 src="https://tetr.io/res/league-ranks/{{ .Site.Params.TETRIO_RANK }}.png" />)
</span>

Which looks like this: 11126.88 TR (). To keep this value up-to-date, I add it to a GitHub Actions workflow that uses the game’s API to retrieve my TR and rank, and replaces the current value in the hugo.toml file using sed.

Visualising multi-sport events

Fri, 16 Aug 2024 00:00:00 +0000

Today, I participated in my first duathlon — 5 kilometres of running, followed by 32 kilometres of cycling, and finishing with another 5 kilometres of running:


Run #1	00:24:54
⋮ Transition #1	00:01:06
Bike	01:21:49
⋮ Transition #2	00:01:53
Run #2	00:23:44
⋮ Total	02:13:28

As I do with my separate running or cycling sessions, I record my performance (HR, power output, pace) and upload it to Strava and intervals.icu. It surprises me, however, that there is no clear way of combining these separate activities into one multi-sport event. I assume there’s much to gain when looking at these activities in their context, rather than separately.

As a small side project, I could look into the best way of combining the different .fit-files into one well-visualised multi-sport event. It would surprise me if no one else has done this before, but this idea gives me the best opportunity to dive into how these files are structured (as I am totally unfamiliar with how they work) and how I could combine them in one multi-sport visualisation.

I could use the data from different .fit-files to display some maps of the course and compare the first and last running segments of a duathlon, for example. I could show a well-visualised race timeline with interesting annotations like weather conditions and elevation profiles, and the location of the highest achieved heart rate and power output. For friend groups participating in the same event, I could show different participants’ data on the same visualisation, to easily let them compare their performance.

Target power to predicted race time

Thu, 15 Aug 2024 00:00:00 +0000

For both training and racing, I use a Stryd pod: a running power meter that allows me to base my running on my power output, instead of looking at my pace or heart rate (which are both influenced by elevation). The Stryd running pod calculates my Critical Power (CP), which is similar to Functional Threshold Power (FTP). My CP is currently 3.490 W/kgData from intervals.icu (and was 3.75 W/kg at the time of writing) — something that I want to keep improving as I’m planning to run my second marathon mid-September.

Predicting finish time with Stryd

The Stryd app has two handy features: one predicts race calculations for a set of fixed distances (1 mile, 5k, 10k, HM, and full marathon) and the other returns a target power + predicted race time based on CP for a given GPX. I was wondering how they calculate these predicted race times, and stumbled upon a blog post by Stryd themselves.

Their simplified formula — specifically meant for a flat course with no air resistance — is rather straightforward: $T = \frac{1.04 * d}{TP / m}$, where $T$ is the predicted race time in seconds, $TP$ is the target power for the race in watts, $m$ is the runner’s body weight in kilograms, and $d$ is the distance in meters:

from datetime import timedelta

def predicted_time(d, TP, m):
	seconds = 1.04 * d / (TP / m)
	return str(timedelta(seconds=seconds))

“In Flanders Fields” marathon prediction

For my next marathon, I am trying to go for a time under 4 hours. As my target power is ~250 W, I would finish my next marathon in 3 hours and 51 minutes, in the best case scenarioFlat course, but weather can have a big impact.

d = 42195 # marathon distance in m
TP = 250 # target power in W
m = 79 # weight in kg

>>> predicted_time(d, TP, m)
'3:51:06.964800'

This is pretty similar to the Stryd app’s estimated time based on the provided GPX of the marathon course, which predicts I will run the marathon in around 3 hours and 50 minutes — if I can maintain an average power output of ~252 W. Using the simplified formula directly, however, gives me a bit more flexibility to see what my predicted time would be if I increase my target power or lose weight, but retain my CP:

weight = range(80, 74, -1)
time = [predicted_time(d, TP, w) for w in weight]

>>> for w, t in zip(weight, time):
... print(f"{w} kg — {t}")

'80 kg — 3:54:02.496000'
'79 kg — 3:51:06.964800'
'78 kg — 3:48:11.433600'
'77 kg — 3:45:15.902400'
'76 kg — 3:42:20.371200'
'75 kg — 3:39:24.840000'

Stryd also just released a blog post about Clayton Young and his preparation for the Olympic Marathon in Paris, in which he finished 9th: Stryd predicted his finish time at 2:09:54, and he ultimately ran 2:08:44.

Pomodoro timer in a terminal

Wed, 14 Aug 2024 00:00:00 +0000

I usually use the Pomodoro Technique to schedule my work: intervals of 25 minutes of work, followed by a 5 minute break. Traditionally, I used pomofocus.io as a timer in my browser that alerts me when an interval is over. As I often have a terminal emulator opened somewhere — and as I wanted to keep track of the number of finished pomodori in Obsidian, it made more sense to create my own shell script that:

Starts a 25 minute timer, alerting me when time runs out
Gives me the option to take a break, starting a 5 minute timer
Keeps alternating between work and break intervals until I stop working
Keeps track of finished pomodori for the day in my Obsidian work vault

Displaying a timer

Below, we define a function that takes a label (e.g., working or taking a break) and the amount of seconds the countdown should take. We start by moving the text cursor to the upper left corner using echo -ne '\033[2A'StackOverflow, and then, as long as our variable time_left is larger than -1:

Show the label in bold, using \033[1m• $label\033[0m
Format remaining time using $(date -d@$time_left -u +%M:%S), so that it shows as remaining time in minutes and seconds, instead of just seconds
Use \033[0K to delete text to the end of the line, and \r to move to the beginning of the current lineStackOverflow
Wait one second using sleep, and substract 1 from the time_left variable

display_timer() {
 local label=$1
 local time_left=$2
 echo -ne '\033[2A'
 while [ $time_left -gt -1 ]; do
 echo -ne "\033[1m• $label\033[0m — $(date -d@$time_left -u +%M:%S)\033[0K\r"
 sleep 1
 ((time_left--))
 done
}

We can start and display our work timer and break timer as shown below. We start a 25 minute timer (displayed as • Work left — MM:SS), immediately followed by a 5 minute timer (displayed as • Break left — MM:SS):

WORK_TIME=$((60 * 25)) # Work time (25 minutes)
BREAK_TIME=$((60 * 5)) # Break time (5 minutes)

display_timer "Work left" $WORK_TIME
display_timer "Break left" $BREAK_TIME

Keeping track of 🍅’s

In my Obsidian journal, I have daily notes where I keep track of work done, to-dos, and ideas. I recently added a pomodori field to the properties of my Markdown files, where I keep track of how many work intervals I have done that day:

---
date: 2024-08-14
type: research journal
pomodori: 🍅🍅🍅🍅
---

I want this script to automatically add a new interval to this property, by first defining the path to today’s note and then appending a 🍅 to the end of the line of that property using sed. As the property will always be on the fourth line of my notes, we can write:

WORK_TIME=$((60 * 25)) # Work time (25 minutes)
BREAK_TIME=$((60 * 5)) # Break time (5 minutes)
JOURNAL="(⋯)/work/Research Journal"
ENTRY="$JOURNAL/$(date +%Y-%m-%d) Research Journal.md"

display_timer "Work left" $WORK_TIME
sed -i '4s/$/🍅/' "$ENTRY"
display_timer "Break left" $BREAK_TIME

User input to keep going

Using zenity, we can request user input to check if we want to switch from working to taking a break, and vice versa. We use exec "$(readlink -f "$0")"AskUbuntu to restart the script when switching from taking a break back to working:

if zenity --question --title="Pomodoro" --text="Time for a break?"; then
 display_timer "Break left" $BREAK_TIME
 if zenity --question --title="Pomodoro" --text="Time to work?"; then
 exec "$(readlink -f "$0")" # Restart the script for another Pomodoro cycle
 fi
fi

Putting it all together

#!/usr/bin/env bash
clear

# Paths and file names
JOURNAL="(⋯)/work/Research Journal"
ENTRY="$JOURNAL/$(date +%Y-%m-%d) Research Journal.md"

# Pomodoro timers (in seconds)
WORK_TIME=$((60 * 25)) # Work time (25 minutes)
BREAK_TIME=$((60 * 5)) # Break time (5 minutes)

# Function to display the timer
display_timer() {
 local label=$1
 local time_left=$2
 echo -ne '\033[2A'
 while [ $time_left -gt -1 ]; do
 echo -ne "\033[1m• $label\033[0m — $(date -d@$time_left -u +%M:%S)\033[0K\r"
 sleep 1
 ((time_left--))
 done
}

# Start the work session
display_timer "Work left" $WORK_TIME

# Add a 🍅 emoji to the fourth line of the journal entry
sed -i '4s/$/🍅/' "$ENTRY"

# Prompt to take a break
if zenity --question --title="Pomodoro" --text="Time for a break?"; then
 display_timer "Break left" $BREAK_TIME
 if zenity --question --title="Pomodoro" --text="Time to work?"; then
 exec "$(readlink -f "$0")" # Restart the script for another Pomodoro cycle
 fi
fi

I have added clear to the beginning of the script to clear the terminal screen before the script runs, just to ensure a clean display of the timer:

Demonstration of Pomodoro timer

Scraping TETR.IO Tetra League standings

Tue, 13 Aug 2024 00:00:00 +0000

Since 2022, I’ve regularly enjoyed playing a competitive Tetris variant named TETR.IO. It’s been a while since I have played the game, but when visiting its website I read that the game just moved from it’s Alpha stage to Beta, and that the second season of TETR.IO’s TETRA LEAGUE (the game’s competitive matchmaking mode) starts on the 16th of August.

Something that I missed in the Alpha version of the game was the history of progression: I would have loved to see a plot that shows my rank and the game’s equivalent of my ELO score over time. With the second season of the game fast approaching, it is the perfect time to create a cron job for a script that scrapes my TETR.IO profile and writes the current score to a file. The data itself could then be used to create my plot, and maybe showcase it on my website.

Inspecting the HTML of the TETR.IO profile pages, the score is normally displayed in the following div. Because it is the off-season, however, there is no score to display:

<div class="card categorical" id="usercard_league" style="--color: #375433">
	<h1><img src="/res/league.svg">TETRA LEAGUE</h1>
	<h6 id="user_league_np">Off-season</h6>
	<div id="user_leagueset">
		<div id="user_leaguestateset"></div>
		<div id="user_leaguestandingset" class="standingset">abc</div>
	</div>
	⋯
</div>

Initially, I planned to simply scrape this using:

curl -s "https://ch.tetr.io/u/geuze" | grep -oP '(?<=<h6 id="user_league_np">).*?(?=</h6>)'

A simple curl and grep of the webpage won’t do, however, as the information seems to be loaded using Javascript. Before the beginning of this new season, I’ll look into scraping Javascript-rendered web pages using Python.

Partially ordered sets with cycles

Mon, 12 Aug 2024 00:00:00 +0000

A partially ordered set — or poset — $P = (A, \preceq)$ is a pair consisting of a set $A$ and a partial order $\preceq$ on $A$. This partial order is a binary relation on a set $A$ such that — for all $x, y, z \in A$ — it is:

reflexive ($x \preceq x$),
antisymmetric ($x \preceq y$ and $y \preceq x$ imply $x = y$),
and transitive ($x \preceq y$ and $y \preceq z$ imply $x \preceq z$).

For two elements $x, y \in P$, we say that $y$ covers $x$ if $x \prec y$ and there is no element $z \in P$ such that $x \prec z \prec y$. We write this as $x \lessdot y$.

I assumed that every poset could be described as a directed acylic graph through the cover relation between its elements. This intuitively makes sense to me, as cycles (e.g., $x \lessdot y$ and $y \lessdot x$) would be inconsistent with posets due to its antisymmetry, but $x \neq y$ given the definition of the cover relation. Thinking about cycles in orders reminded me of this great example on the link between directed acyclic graphs and genealogy, from the Handbook of Graph Theory by Jonathan L. Gross:

A “family tree” is a digraph, where the orientation is traditionally given not by arrows but by the direction down for later generations. Despite the name, a family tree is usually not a tree, since people commonly marry distant cousins, knowingly or unknowingly. However, it is always a DAG, because if there were a cycle, everyone on it would be older than everyone else on the cycle.

Handbook of Graph Theory by Jonathan L. Gross

I did, however, stumble upon a paper titled “Cyclic Ordering through Partial Orders” by Stefan Haar. Briefly scanning through the paper shows some interesting concepts, so I am certainly curious to learn more about this!

Describing activities with sparklines

Sun, 11 Aug 2024 00:00:00 +0000

Yesterday, I learned about sparklines — “data-dense graphics with typographic resolution that is shown inline and in-context with relevant text.”

When thinking about how I could use sparklines in an original way within my personal website, I thought they would be interesting to convey properties of sports activities. One could add the elevation profile of a course 🏔️ {22,17,27,37,32,27,37,32,27,22,32,27,37,32,27,37,47,42,52,47} , or a heart rate curve ❤ {22,17,27,37,32,27,37,32,27,22,32,27,37,32,27,37,47,42,52,47} and power output ⚡︎ {22,17,27,37,32,27,37,32,27,22,32,27,37,32,27,37,47,42,52,47} over time, as a sparkline within a blog post about a race.

With the help of Sparks, which is a typeface for creating sparklines in text, this was implemented quickly:

{{< sparkline class="bar-medium" color="darkgreen">}} 🏔️ {22,17,27,37,32,27,37,32,27,22,32,27,37,32,27,37,47,42,52,47} {{</ sparkline >}}

{{< sparkline class="dotline-medium" color="crimson">}} ❤ {22,17,27,37,32,27,37,32,27,22,32,27,37,32,27,37,47,42,52,47} {{</ sparkline >}}

{{< sparkline class="dotline-medium" color="purple" >}} ⚡︎ {22,17,27,37,32,27,37,32,27,22,32,27,37,32,27,37,47,42,52,47} {{</ sparkline >}}

In the future, I’d like to use actual data from intervals.icu for these sparklines.

Exploring breakfast spots with Overture Places

Sat, 10 Aug 2024 00:00:00 +0000

I recently learned about Overture places data through a blog post by Drew Breunig. This dataset “contains more than 53 million point representations of real-world entities: schools, businesses, (⋯), mountain peaks, and much more"Places - Overture Maps Documentation. You can explore this data through the Overture Maps Explorer.

I regularly have breakfast with a friend, and we like exploring new breakfast places. The Overture dataset could provide us with new breakfast places in Brussels. For this, we need the bounding box around the area of Brussels in which we’re interested in. We can find this using bboxfinder.com. For this example, we take the bounding box around the Vijfhoek of Brussels.

Screenshot of the bounding box around the Vijfhoek of Brussels

Checking out some of the regular places we visit through the Maps Explorer shows that they have the "breakfast_and_brunch_restaurant" category in common. Using duckdb, we can download all places within our defined bounding box of 50.832939, 4.337368, 50.858410, 4.369812. The code below is based on an example from the Overture Maps website:

-- Load necessary modules
LOAD spatial;
LOAD httpfs;

-- Set the AWS S3 region
SET s3_region = 'us-west-2';

-- Copy the filtered data from S3 to a local Parquet file
COPY (
 SELECT
 id,
 names,
 categories,
 websites,
 addresses,
 ST_GeomFromWKB(geometry)
 FROM 
 read_parquet('s3://overturemaps-us-west-2/release/2024-07-22.0/theme=places/*/*')
 WHERE
 -- Filter by bounding box (xmin and ymin)
 bbox.xmin BETWEEN 4.337368 AND 4.369812 AND
 bbox.ymin BETWEEN 50.832939 AND 50.858410
) TO 'vijfhoek.parquet';

Next, we can query all the places where the primary category is "breakfast_and_brunch_restaurant":

SELECT 
 names.primary AS name, 
 addresses[1].freeform AS address, 
 websites[1] AS website
 FROM 
 'vijfhoek.parquet'
 WHERE 
 categories.primary = 'breakfast_and_brunch_restaurant';

┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ name │ address │ website │
│ varchar │ varchar │ varchar │
├──────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Flower food │ Rue Blaes 264 │ │
│ Le Père Tranquille │ Rue des Renards 4 │ │
│ Brussels Waffle Workshop │ Rue des Foulons 30 │ http://www.waffleworkshop.com │
│ Woodpecker 20 │ Rue Jourdan 20 │ │
│ EatClub Brussels │ Rue de Stassart 18 │ │
│ Café Boudin │ Rue Ravenstein 20 │ https://cafeboudin.be │
│ bloom_and_brunch_by_sabri │ Rue de la Paix 7 │ │
│ Lastra │ Rue du Conseil 24 │ │
│ Le Coin Des Saveurs │ Boulevard de l'Abattoir 19 │ │
│ Kandinsky │ Chaussée de Gand 37 │ https://kandinsky-family.be/ │
│ Restaurant Baurade │ Boulevard Anspach 153 │ │
│ Kafei Dansaert │ Rue Antoine Dansaert 57 │ https://kafei.be │
│ Le Odin Royal │ Oude Graanmarkt 2 │ │
│ Movenpick │ │ │
│ Woodpecker St. Cath. │ Quai au Bois à Brûler 27 │ │
│ Restaurant Al Andalus │ Rue de Ribaucourt 4 │ │
│ Gaufres and Waffles │ Chemin du Croquet 1 │ http://www.gaufresandwaffles.com │
│ Oats Day Long │ Europakruispunt 3 │ https://www.oatsdaylong.com │
│ Belrose cake │ Boulevard Émile Jacqmain 3 │ https://www.belrosecake.com/ │
│ Spread the moon │ Rue du Gentilhomme 13 │ https://www.instagram.com/spreadthemoon/ │
│ Longitude Nord-Sud │ Quai aux Pierres de Taille 14 │ http://longitude.blog4ever.com/ │
├──────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ 21 rows 3 columns │
└──────────────────────────────────────────────────────────────────────────────────────────────────────┘

This is a good start, but lots of places we already visited are still missing from this list. We can query for all places where 'breakfast_and_brunch_restaurant' is listed under alternate categories using OR 'breakfast_and_brunch_restaurant' = ANY (categories.alternate);.

I’m planning to pick this idea up later, and check if I can find a way to include more breakfast and brunch spots. In a next step, I could attempt to scrape the provided websites to check menus for our usual order.

intervals.icu, GitHub Actions, and Hugo shortcodes

Fri, 09 Aug 2024 00:00:00 +0000

Intervals.icu API

I sync all my Strava activities to intervals.icu, which calculates my training load, fitness score, and my weekly ramp rate. To test out this platform’s API, I wanted to calculate the distance that I ran or cycled given a custom date range, as this is something that I don’t immediately see inside intervals.icu itself. GET /api/v1/athlete/{id}/activities returns a list of activities between the parameters oldest and newest:

BASE_URL="https://intervals.icu/api/v1/athlete"
OLDEST="2024-01-01"
NEWEST="2024-12-31"
curl -s -u API_KEY:$API_KEY \
 "$BASE_URL/$INTERVALS_UID/activities?oldest=$OLDEST&newest=$NEWEST"

As we can’t select specific activity types through the API (we’re only interested in runs for this example, but this list contains all types of activities), I made use of jq — “a lightweight and flexible command-line JSON processor” — to select the name, start time, and distance of running activities only:

BASE_URL="https://intervals.icu/api/v1/athlete"
OLDEST="2024-01-01"
NEWEST="2024-12-31"
curl -s -u API_KEY:$API_KEY \
 "$BASE_URL/$INTERVALS_UID/activities?oldest=$OLDEST&newest=$NEWEST" | \
jq '[.[] | select(.type == "Run") | {name, start_date_local, distance}]'

[
 ⋯,
 {
 "name": "Night Run",
 "start_date_local": "2024-08-06T21:44:54",
 "distance": 6699
 },
 {
 "name": "Afternoon Run",
 "start_date_local": "2024-08-06T16:06:24",
 "distance": 3400.5
 },
 {
 "name": "Evening Run",
 "start_date_local": "2024-08-04T20:58:21",
 "distance": 4928
 },
 ⋯
]

This shows that our filter for running activities works. To now sum the distance of all our activities, we just need to select the distance of every activity and map add over it. This returns the total distance in meters.

BASE_URL="https://intervals.icu/api/v1/athlete"
OLDEST="2024-01-01"
NEWEST="2024-12-31"
curl -s -u API_KEY:$API_KEY \
 "$BASE_URL/$INTERVALS_UID/activities?oldest=$OLDEST&newest=$NEWEST" | \
jq 'map(select(.type == "Run") | .distance) | add'

701168.5

GitHub Actions for Hugo shortcode

As I wanted to do something with this distance, I made a GitHub Actions workflow that calculates the distance every day at midnight and uses sed to replace the Hugo variable .Site.Params.distanceRun. Using this variable, I created a Hugo shortcode {{< distance_run >}} that returns the distance run in kilometers:

{{- $distanceMeters := .Site.Params.distanceRun -}}
{{- $distanceKilometers := div $distanceMeters 1000 -}}
{{ printf "%.1f" $distanceKilometers }} km

Using {{< distance_run >}} in a Hugo content file returns: 418.2 km. I can put this value in a tooltip with an explanation of the value, which is displayed as 418.2 kmTotal distance since 1st of Jan.:

{{< tooltip >}}{{< distance_run >}} | Total distance since 1st of Jan.{{</ tooltip >}}

Tooltip on mouse hover with Hugo

Thu, 08 Aug 2024 00:00:00 +0000

I added custom tooltipsJust like this one! to this website, as I want to provide extra information to specific text in my posts and notes. This can be done using regular shortcodes, which are simple snippets inside a content file that Hugo will render using a HTML template:

{{< tooltip outer_text="tooltips" tooltip_text="Just like this one!" >}}

This works fine if we just provide simple, static text. One of the criteria for my tooltip shortcode, however, is that I should be able to put other shortcodes inside them, as I have a couple of shortcodes that make use of variables that are updated automatically using GitHub Actions. One example of this is the number of kilometers I ran this year (418.2 km, currently)Updated using GitHub actions + intervals.icu , which I calculate using the intervals.icu API.

As far as I know, there is no standard way of adding these tooltips in Hugo. I created them myself by using paired shortcodes and using .Inner to return the content between the opening and closing shortcode tags, which allows us to do the following:

{{< tooltip >}} {{< inner_shortcode >}} {{</ tooltip >}}

Now, we can get the contents of the inner shortcode through .Inner:

<span class="tooltip">
 {{- .Inner | safeHTML -}}
 <span class="tooltiptext">{{- .Inner | safeHTML -}}</span>
</span>

We want to put some text as the outer text of the tooltip, and other text in the tooltip box itself, however. Through a hack provided by someone on the Hugo forum, we can split up .Inner by providing a custom delimiter. For my tooltips, I divide the contents of the paired shortcodes in the outer text and the tooltip text using |:

{{- $children := split .Inner " | " -}}
<span class="tooltip">
 {{- index $children 0 | safeHTML -}}
 <span class="tooltiptext">{{- index $children 1 | safeHTML -}}</span>
</span>

This way, I can define tooltips like this, for example: 418.2 kmUpdated using GitHub actions + intervals.icu

{{< tooltip >}} {{< distance_run >}} km | See intervals.icu {{</ tooltip >}}

Daily notes with GitHub Actions

Wed, 07 Aug 2024 00:00:00 +0000

I am using GitHub Actions to automatically create new daily notes on this website. Every day at midnight, a GitHub Action checks the content/notes folder for a file titled %Y-%m-%d.md (matching the current date). If this file does not yet exist, a new %Y-%m-%d.md file with a standard Hugo front matter — filled in with the current date and a placeholder title — is created.

To keep track of my daily writing streak, I also need to check if the previous day’s note was modified, and update my streak accordingly. I do this using a combination of git, grep, and sed.

`git log`

The git log command shows the commit log, which is used to check if there have been any other commits involving the previous day’s note, outside of its creation by GitHub Actions. If this is the case, there should be more than one commit involving this file, and I can thus assume that I have written something. Based on this output, the existing streak — which is stored in the hugo.toml configuration file — is updated.

PREV_DATE=$(date -d "${{ env.DATE }} -1 day" +'%Y-%m-%d')
if [[ $(git log --name-only --since="24 hours ago" \
	 --pretty=format: -- \
	 content/notes/$PREV_DATE.md | \
	 grep -c content/notes/$PREV_DATE.md) -gt 1 ]]; then
 echo "MODIFIED=true" >> $GITHUB_ENV
else 
 echo "MODIFIED=false" >> $GITHUB_ENV
fi

For this to work, however, we need to pass the HEAD’s SHA as a ref to the checkout:

- name: Checkout repository
 uses: actions/checkout@v3
 with:
 ref: ${{ github.event.pull_request.head.sha }}
 fetch-depth: 0

`grep`

To find the current value of the writing streak in the configuration file — and the corresponding date that matches this streak — I use grep. These outputs are stored in environment variables.

CURRENT_STREAK=$(grep -Po '(?<=CURRENT_WRITING_STREAK = )\d+' $TOML_FILE)
CURRENT_STREAK_DATE=$(grep -Po '(?<=CURRENT_WRITING_STREAK_DATE = )\d{4}-\d{2}-\d{2}' $TOML_FILE)

`sed`

The streak value in the configuration file is updated using sed, based on our earlier result from the git log command. We replace the current streak value with $((CURRENT_STREAK + 1)) if there is more than one commit involving the previous day’s note, or replace the streak with 0 otherwise. This new streak is stored in the $NEW_STREAK environment variable. We also do the same to keep track of the best writing streak to date.

sed -i "s/CURRENT_WRITING_STREAK = $CURRENT_STREAK/CURRENT_WRITING_STREAK = $NEW_STREAK/" $TOML_FILE
sed -i "s/CURRENT_WRITING_STREAK_DATE = $CURRENT_STREAK_DATE/CURRENT_WRITING_STREAK_DATE = ${{ env.DATE }}/" $TOML_FILE

The above sed command kept throwing an error, however: sed: -e (...) unterminated 's' command. I tried everything from attempting to escape underscores, to adding -- to sed (as maybe the hyphens in the dates could be confused with a sed option that made something break), as I first thought that these characters were possibly causing these issues.

In the end, I realised that the issue was caused due to grep matching multiple lines in the hugo.toml — which also included newlines and spaces. I did not realise that newlines would be included in the environment variables, but making sure the regex match was only limited to the CURRENT_WRITING_STREAK variable in the configuration file and trimming any newlines, resolved the issue:

CURRENT_STREAK=$(echo "$CURRENT_STREAK" | tr -d '\n' | tr -d ' ')
CURRENT_STREAK_DATE=$(echo "$CURRENT_STREAK_DATE" | tr -d '\n' | tr -d ' ')

By double-checking the used regex and removing unwanted characters, the sed command could successfully update the values in the hugo.toml file without errors:

Writing streak of 0 daysUpdated on May 10, 2026
Best writing streak to date is 20 daysAchieved on Aug 27, 2024

Patrick Van der Spiegel's Notes

Maasmarathon

Anagram hikes

< 1000 kilometres in 2025

1000 kilometres in 2024

Common Favourite Films on Letterboxd

Scraping Fans

Finding Similar Profiles

Automatically Following Profiles

llm + Espanso: Clipboard Summaries

Can GPT Boggle?

git mailmap

Joining Mastodon

CSS filter posts by category

Python packaging in Rust

Tracking tasks in Obsidian

Learning Rust

Terminating statements with ;

Cargo and initialising Git repositories

Shadowing of immutable variables

Visual separator for integer literals

Other things that I like so far, at first glance

Visualising Belgian roads

Displaying tags in Hugo

Using data sources in Hugo

Displaying TETR.IO TR on website

Visualising multi-sport events

Target power to predicted race time

Predicting finish time with Stryd

“In Flanders Fields” marathon prediction

Pomodoro timer in a terminal

Displaying a timer

Keeping track of 🍅’s

User input to keep going

Putting it all together

Scraping TETR.IO Tetra League standings

Partially ordered sets with cycles

Describing activities with sparklines

Exploring breakfast spots with Overture Places

intervals.icu, GitHub Actions, and Hugo shortcodes

Intervals.icu API

GitHub Actions for Hugo shortcode

Tooltip on mouse hover with Hugo

Daily notes with GitHub Actions

git log

grep

sed

Terminating statements with `;`

`git log`

`grep`

`sed`