Setting up a build environment with both repositories (coreutils and gnulib) was quite a challenge, due to git submodules and autotools. The necessary patches, on the other hand, looked quite straightforward: add the new formats in lib/parse-datetime.y and have bison generate the new parser.

But it didn’t work: I still got bad format errors. However, if I used anything other than a dot as a separator (such as a comma or a pipe), it did work. This led me to the logic that parses decimal/nanoseconds in the lexer, which is not intuitive. I didn’t want to touch too much unrelated code, so I added a flag to not mangle the new format. I might revisit this someday if I come up with a cleaner design.

Then I added some tests and the docs, which was mostly straightforward again. The tests are rather sparse, spread over the two repositories and often use Perl or Bash scripts, which I had to understand first. Despite my attempts, I also didn’t get the GNU formatting completely right. Thankfully, the maintainer handled that and the test failure on Windows (apparently “Year 0003 is not supported there”). Thanks, Pádraig Brady.

When can I use it?

On rolling-release and faster-updating distros like Fedora, right now. On Debian, probably with the next release on a yet to be announced date.

On Ubuntu, you’ll need to wait until they release a new version based on the next Debian and then install the GNU coreutils yourself. Ubuntu now uses uutils by default, the Rewrite in Rust︎™ of coreutils.

All in all, I got to explore a foundational piece of GNU/Linux distributions, and learned how to send git patches via mail. Let’s see if I get to improve the Rust version, too.

That’s where Grafana Live comes in, which allows you to stream data in (soft) real-time. For example, let’s say we have the data in a Python script:

import random
import time

alt = random.uniform(0, 1000)
speed = random.uniform(0, 100)

for _ in range(500):
    alt += random.uniform(-5, 5)
    speed += random.uniform(-1, 1)
    time.sleep(0.1)

How do we get it into Grafana?

The official documentation suggests creating a full-blown TypeScript + Go plugin or setup Telegraf. None of that is necessary, you can just use the new API endpoint /api/live/push/:streamId directly:

import os
import random
import requests
import time

url = "http://localhost:3000/api/live/push/test_stream"
headers = {"Authorization": "Bearer " + os.environ["AUTH"]}

alt = random.uniform(0, 1000)
speed = random.uniform(0, 100)

for _ in range(500):
    alt += random.uniform(-5, 5)
    speed += random.uniform(-1, 1)
    response = requests.post(url, headers=headers, data=f"balloon speed={speed},alt={alt}")
    if response.status_code != 200:
        print(f"Error: {response.status_code} - {response.text}")

    time.sleep(0.1)

Authentication is done with an API token.

Thanks to Grafana89e9 and Smaragda Benetou for pointing this out with code examples.

A lot of people seem to think that performance is about doing the same thing, just doing it faster. And that’s not true. That’s not what performance is all about. If you can do something really fast, really well, people start using it differently. Linus Torvalds

Hot reloading

The first thing Victor demonstrates is already cool: hot reloading. Any code change is immediately visible on the canvas. 13 years later, it’s pretty much everywhere, from frontend frameworks (Flutter, React, Vite, Webpack) to game engines (Unity, Unreal Engine).

What does the code do?

Now, let’s step up the game. Take a look at this:

The connection between code and result is immediately visible. It also works the other way round; you can select any pixel to highlight the code responsible for painting it. Element picking is present for many GUI toolkits; going from code to result, however, is exceedingly rare.

Visualizing time

Visualizing a program’s behavior over time is immensely powerful, not just for games. The rr debugger, for example, applies this concept, and the list of testimonials proves this is wanted. Of course, Victor takes this to the next level, also allowing changes and visualizing the new timeline.

Debug programming

How do we debug programs?
With interactive tools showing us the state of the program for specific arguments, so we can confirm our assumptions.

Why is it a separate step from programming? Why do we only use this once bugs have already caused issues?

Well, Victor does it better. By including the debugger in the programming environment, we can immediately see the state of the program for any input we want.

2025-02-28: There has been an attempt to create such an IDE.

2025-04-02: Obviously Jupyter Notebooks, and their extensions are a step in this direction.

Conclusion

Inventing on Principle is a really great talk with incredibly good ideas. If I get the time, I’ll implement some of these.

1. Enable Bluetooth sharing in Settings > General > Sharing
   See Apple’s guide for a longer explanation
2. Now, this is the same as in Apple’s guide

   Open the Bluetooth File Exchange (located in the Utilities folder in the Applications folder)

3. The guide’s step 2 is impossible here, File > Send File is greyed out. You’ll get a popup that lets you browse other devices. We don’t want that, so click Cancel, and then, while the same app is still selected, you can finally
4. use File > Send File.
5. Select the file and device you want and click Send.

First, border supports gradients, so maybe we can use this property?

Taken from this excellent blog post, it’s almost what I want. Unfortunately, though, it doesn’t support rounded edges. Also, it uses a custom property, and despite the post being three years old, custom properties are still not a thing in all browsers. There’s a workaround included, essentially generating the expected animation for the browser, but it’s a lot of boilerplate, and I don’t like bloating my file just for this.

Another option is using a pseudo-element behind the button and setting its background. I played around with this, and it seemed like the best option. Unfortunately, I only found an example with a linear gradient while I wanted a conic one. Changing the gradient type is easy, but then the animation was broken. Moving the background-position works only for the scaled up linear gradient. If I apply a rotate animation directly, we get this:

We need to clip away anything not part of the border. I searched for clipping but only ended up with clip-path, svgs and the likes, which could maybe work, but would be a hassle. masks also didn’t look too promising.

Finally, overflow saved me. I hadn’t seen the overflow: clip property, and low and behold, it also comes with overflow-clip-margin, giving us the space for a beautiful border. This is perfect! Now, I just had to center the pseudo-element, one of the most infamous tasks in CSS. Luckily inset: 0 combined with margin: auto gets us almost there, but for some reason, we also need to override left with the explicit indentation to offset the oversize width. This is the final result, and although it feels a bit cursed, it works™:

pg_dump: error: query failed: ERROR: permission denied for view pg_roles

I don’t know why pg_dump needs to access the pg_roles view, but it does and fails if it can’t. Maybe we can find a way to skip this roles access? I don’t want any roles, I just want the data.
There are multiple promising options in the help menu that I tried:

-O, --no-owner               skip restoration of object ownership in plain-text format
-a, --data-only              dump only the data, not the schema
-t, --table=PATTERN          dump the specified table(s) only

Unfortunately, none of them solved the problem, the error persisted.

So I searched for a different way to export the data and I found a way. It’s not as elegant as pg_dump, but it works and that’s what counts. We can use the COPY command to move data between a table and a file.

Here’s StackOverflow’s way to export a table from any SQL database into a CSV file:

echo "\COPY (select * from table ) TO 'table.csv' (format CSV);" > my_query.sql
psql <database> -af my_query.sql

We use the backslash to make it a client command, so psql will look in the current directory for the file. If you use COPY without the backslash, the server will look for the file.

An even shorter answer without a helper file is found in the comments.

psql <database> -c 'select * from table limit 5' -tAF , > table.csv

For importing the data back into a database, you can then use the \COPY command again:

psql <database> -a -c "\COPY table FROM 'table.csv' CSV"

A simple Python script is enough to read the file and count the occurrences of each digit. We can use a dictionary to store the counts, which is initialised with 0 for each digit.

with open("1-1000000.txt") as f:
    pi = f.read()
    count = dict((str(i), 0) for i in range(10))
    for digit in pi:
        count[digit] += 1
    print(count)

Et voilà, the result:

{'0': 99959, '1': 99758, '2': 100026, '3': 100229, '4': 100230, '5': 100359, '6': 99548, '7': 99800, '8': 99985, '9': 100106}

This is only counting digits after the decimal point, to include the first 3 increase the count for 3 and take away the 1 at the millionth place.

If you want to see it as a nice graph, add the following code:

import matplotlib.pyplot as plt

plt.bar(count.keys(), count.values())
plt.show()

The distribution is pretty even, so you might consider using Pi as a (pseudo) random number generator. It would be pretty good on its own (study 1, study 2, 10 million digits), but randomness is usually meant as unguessable numbers (at least without significant effort). As soon as someone recognizes the sequence, the surprise is gone and for example getting “random” rewards in a game becomes predictable and boring. On the other hand, most people only know the first few digits of Pi, so if you start with a large enough offset, you should be fine.