Myke's Blog

Managing a music collection with AI

Tue, 05 Aug 2025 24:00:00 GMT

I started collecting music as soon as I found out about this new hot format called MP3 back in the 90s. Then I lost it all to streaming services - I probably still could recover it, but that would require going through old backups. And most of it was pirated anyway, which contradicts my current views on how things should work in the world (so does using Spotify, because artists get next to nothing). So I decided to rebuild my music collection officially buying it from sites like bandcamp.

Which brought up the question of organizing it all.

But both back in the day and now the worst part about a music collection was keeping it well-structured, with pretty file and folder names, sorted correctly, album art and all. I used to have energy to edit metadata by hand (heck, I remember ripping my own CDs into MP3s). But I'm too lazy for this shit now.

Enter Claude Code (but you could do the same with gemini, opencode, claude desktop with some MCP, etc).

The Setup

I keep my music collection in ~/Sync/Music/ with a strict directory structure: Artist/YEAR - Album Title/. This folder automatically syncs using syncthing to my home server, from where I can stream it wherever I want. When on my computer I use rmpc player to listen to it, because I'm so badass that only a terminal player will satisfy me.

When on the go I stream from a self-hosted Navidrome, but to be honest, I mostly listen to music while working.

To maintain consistency, I created a CLAUDE.md file in the music directory with organizational rules and import procedures (well, I actully told Claude what I want and it created the file for me, then I just edited it).

Then I asked it to bring order and reorganize my collection, which took it about 10 minutes, including the time to look up albums and artists info online. For example I had an album where all tracks were sorted alphabetically, so I told it to order them according to the actual album. The result is a perfect folder structure of ARTIST / YEAR - ALBUM, with album covers (although it did try to generate album art instead of looking it up online at some point).

Anyway, this is a very nice use of AI to handle a boring non-coding task. Some technical details:

The Import Process

When downloading a new album, I can run:

claude -p "import ~/Downloads/album.zip"

The CLAUDE.md file instructs Claude to:

Extract the zip file
Check if the metadata is correct and fix it if necessary
Look up the release year
Create the proper directory structure in my Music directory
Move files to the organized location
Update the MPD database, so that the new music immediately appears in the player

Look how neat the import is:

Here's the CLAUDE.md file used in case you want to try it yourself.

New Sanskrit Dictionary

Mon, 23 Dec 2024 24:00:00 GMT

It is obvious that the hardest part (by far, far, very far) of the work was done a while ago, when the amazing people from the Cologne University in Germany digitized and published Cologne Digital Sanskrit Dictionaries. They even made all the 36 or more dictionaries available online for anybody to use (and in different formats too).

The only problem with the web interface they provided was that it is that the UI is a little... too academic for my taste. It also only searches in one dictionary at once, and only for exact matches.

It was clear that improving the UI will give great advantages to researches and students, and there were several improvements I wanted:

Let the users type using IAST (Latin transcription) or Devanagari, because the program can tell the difference by itself
Make it possible to search in any number of dictionaries at once
Add fuzzy search (so that it was possible to find approximate matches and similar words)
Add full-text search across the articles (not just the words), effectively creating the largest bi-directional dictionary out there

So, long story short, I finally made it happen and launched sanskrit.myke.blog with all of the above. I hope you'll enjoy using it!

Some technical stuff for the nerds

When creating the GUI version before I wrote a migrator that migrated all the articles into a SQLite database, which shipped with the dictionary. It seemed to make sense both in terms of performance and convenience of search. The resulting program is not slow, but it's not super fast either. I didn't like that.

On this iteration I thought a bit more and there was a very obvious idea: you only need a database when you're going to be writing to it. That's not what a dictionary does, what it does is reading, so if I wanted to make it quick all I needed was a good data structure that sits in RAM waiting for reads.

So as a result not only is the web version much quicker (minus the network transfer time), but it ended up being just a fraction of the original code base. And I know that there is additional performance improvement waiting by adding additional indexes, which I can do next time I have inspiration.

Clojure interactive development 101

Sat, 31 Aug 2024 24:00:00 GMT

The question was asked once again — so I'm writing some code into REPL and seeing the results, but that's not very convenient. So I decided to write a small intro on how to do interactive development (a.k.a. REPL-driven development) conveniently.

So, to get the elephant out of the room first: we almost never need to type anything into REPL. The only exception are commands from user.clj file, like (start) or (reload) — but that's a separate subject. But we never type anything like this into REPL:

(defn add-two [n]
 (+ n 2))

Moreover, we don't even type this into REPL:

(add-two 3)

So what do we do? The problem with talking about this is that by nature interactive development is difficult to explain without showing, so I guess I'll use some screenshots. I'll be using Emacs CIDER as my development environment, but the same can be achieved with VS Code and Calva, vim etc. I'm not quite sure about Intellij IDEA, so can't help there.

So let's start.

What is structural editing?

One more thing before we really start.

The main difference of LISPs from "normal" languages is the infamous homoiconicity. The fact that the code is written using the languages own data structures (mostly lists). One of the conclusions from this fact is that there are very clear boundaries between each LISP expression, or s-expression (or s-exp). The brackets.

There is a very practical effect from this fact. When you have something like this (let's pretend that | is the cursor), your editor can easily know that it's standing right after the (+ 2 3) s-exp, and inside the (inc ...) s-exp.

(inc (+ 2 3)|)

It's super trivial for the editor to figure this out. In Python you'd need to count white-spaces to make sure of that, so it's a harder task. In any LISP it's trivial, just the position of the brackets counts.

Ok, now starts the fun part.

Correct way to drive the REPL

So, as I said above we are not going to be typing into the REPL ever again (except for the commands from user.clj). But we are still going to develop interactively.

When we have an expression (+ 2 3), in CIDER we're going to put the cursor right after it:

(+ 2 3)|

And run a command called M-x cider-eval-last-sexp RET (in VS Code and Calva that would be ctrl+alt+enter for Evaluate to cursor), and here's what we'll get:

This is the most important part. The editor has sent the s-exp to REPL, retrieved the evaluation result and showed it to us right next to the s-exp. Congratulations, this is one third of everything you need to know to start developing interactively.

So, we didn't type the expression into REPL, we evaluated the s-exp right from our source file. Big deal.

So, let's look at a real debugging example (well, semi-real). Let's say we have a function:

(defn authorized? [handler]
    (fn [request]
      (if (some-authrorization-logic request)
        "You are authorized"
        "You are NOT authorized")))

As you can see, this is a toy middleware function, that receives a request, runs it through some unknown to us authorization logic, and the returns a string, depending on the result. And this function is not working.

In "normal" languages you would need a tool like Postman to debug this function, constantly reloading your app and running through middleware. But not Clojurians, we have interactive development. Let's use just the one trick we already learned — eval last s-exp.

First of all, we want to capture a request, that's failing, so that we don't need to run Postman over and over again. That's quite easy, for example so:

(defn authorized? [handler]
    (fn [request]
      (def request request)
      (if (some-authrorization-logic request)
        "You are authorized"
        "You are NOT authorized")))

Note that def we have inserted, to define a global variable request. This is a powerful debug mechanism, but a better way to use it is a tool like snitch. Anyway, we ran the request once and now we have the request in the current namespace. How do we check it?

By putting the cursor right after the word request and running the only command we have right now to eval the s-exp right before cursor (and the smallest s-exp is one word):

And we have our request, now we can isolate that piece that we're debugging by using the same command again, but now on the (some-authrorization-logic request) s-exp:

Ah, something with method is not right. Let's experiment some more, same trick, but now we can simplify the argument by reducing request to a map with just one key, since we have a hunch that that's the only thing this function cares about:

Hm, delete didn't work either. Let's try POST:

Bingo, we have figured out what the problem in this most stupid example was using one trick from interactive development. We never restarted our app, we never had to do a second network request (very convenient when doing this right in production), and yet we have figured out what the problem was.

And that's why it's called interactive development, and not REPL-driven development, cause try repeating that in a REPL.

Two more tricks

So, we have learned one trick — evaluating the expression before the cursor, but we need at least two more to be more or less fluent. I'm not going to do all the screenshots, just tell you about them.

By the way, while writing this I noticed that CIDER has at least 20 commands starting with cider-eval-, I'm using only four or five.

Evaluate the top-level form we are in

In CIDER this is done with M-x cider-eval-defun-at-point RET, you can find the similar VS Code command and more examples and videos on the subject in the eval tips article on Calva's website.

As you can see, even though the cursor is standing somewhere inside the inner form, what gets evaluated is the entire function. This helps when you're changing some code and want to check the new definition without leaving the function.

Evaluate the entire file

Most obvious command — edit whatever, and then send the entire file to the REPL to update the running program's state. In CIDER M-x cider-eval-buffer RET, in Calva something something that you can find by following the link above.

Summary

So, I hope that I managed to give you a glimpse of how convenient interactive development can be. We eval expressions that are deep within functions we work with with substituted params to quickly find and fix bugs (even in production, using nREPL).

It's very important to say goodbye to the usual habit of living in the edit-compile-restart cycle and move to the Clojure's blissful cycle of starting the program once and then teaching it to do what you want.

Bonus tip

These two are actually a pair made in heaven. snitch let's you instrument any variables that pass through a function with a simple one symbol substitution, so after add-two is called at least once, n will be available in the global scope:

;; note the asterix after defn
(defn* add-two [n]
 (+ n 2))

(add-two 5)

n ;; => 5

And running (reload) from clj-reload will clean everything up and remove all the variables that got instrumented while playing with snitch, making the namespaces clean again.

Cold war times general Heitor Almendra on preventing a communist coup in Portugal

Wed, 08 May 2024 24:00:00 GMT

At the time of the interview veteran General Heitor Hamilton Almendra was 92 years old, but you could never tell it by his lively spirit and vivid memory. It was a rare honor to be able to bring some of his stories to a broader audience.

Useful Idiots: Lars von Trier

Wed, 23 Aug 2023 24:00:00 GMT

So today we look at an instagram post by renowned Danish director Lars von Trier:

The post reads:

By the way: To Mr. Zelenskyj and Mr. Putin, and not least Mrs. Frederiksen (who yesterday, like someone head over heels in love, posed in the cockpit of one of the scariest killing machines of our time, grinning from ear to ear):

“RUSSIAN LIVES MATTER ALSO!”

Best regards Lars

Interesting point Mr. von Trier. So when Russians bomb our cities we shouldn't defend ourselves because we should care about Russian lives.

What about an extremely simple way of protecting Russian lives: getting out of Ukraine?

It's not the victim's fault that the attacker got injured while attacking. It's the victim's achievement.

So if you want to protect Russian lives then help us stop the war, not put your influence behind their aggression.

On Russian Military Traditions

Mon, 10 Jul 2023 24:00:00 GMT

Mastodon user @kravietz@agora.echelon.pt wrote a small post on how the Russian army behaved during the Afghan war of 1979-89 quoting soldier memoirs^[1], noting that nothing has changed in their behavior and they still act the same today:

In the village one of the sergeants remarked, without hiding his emotion, that 'the young women are good'. The sergeant's words set all the others on fire like a spark, and then he threw off his overcoat and moved on one of the women: — Row, lads! In front of the aksakals and the children, our internationalists had their way with the women. The rape went on for two hours. The children huddled in a corner, screaming and shrieking, trying to help their mothers somehow. The old men, trembling, prayed to their God for mercy and salvation. Then the sergeant commanded, "Fire!" - and was the first to shoot the woman he had just raped. Quickly they finished off all the others as well. Then they poured fuel from the tank of the infantry fighting vehicle, poured it all over the dead bodies, covered them with some clothes, rags and even the scanty wooden furniture and set them on fire. The flames flared up inside the adobe...".

There is no surprise for me in nothing changing in thirty short years because nothing changed for hundreds of years. Let's compare the very fresh quote above with this quote from the pillar of Russian literature Leo Tolstoy^[2] describing the war of the mid-nineteenth century:

The aoul^[3] which had been destroyed was that in which Haji Murad had spent the night before he went over to the Russians. Sado and his family had left the aoul on the approach of the Russian detachment, and when he returned he found his saklya^[4] in ruins -- the roof fallen in, the door and the posts supporting the penthouse burned, and the interior filthy. His son, the handsome bright-eyed boy who had gazed with such ecstasy at Haji Murad, was brought dead to the mosque on a horse covered with a barka; he had been stabbed in the back with a bayonet. The dignified woman who had served Haji Murad when he was at the house now stood over her son's body, her smock torn in front, her withered old breasts exposed, her hair down, and she dug her hails into her face till it bled, and wailed incessantly. Sado, taking a pick-ax and spade, had gone with his relatives to dig a grave for his son. The old grandfather sat by the wall of the ruined saklya cutting a stick and gazing stolidly in front of him. He had only just returned from the apiary. The two stacks of hay there had been burnt, the apricot and cherry trees he had planted and reared were broken and scorched, and worse still all the beehives and bees had been burnt. The wailing of the women and the little children, who cried with their mothers, mingled with the lowing of the hungry cattle for whom there was no food. The bigger children, instead of playing, followed their elders with frightened eyes. The fountain was polluted, evidently on purpose, so that the water could not be used. The mosque was polluted in the same way, and the Mullah and his assistants were cleaning it out. No one spoke of hatred of the Russians. The feeling experienced by all the Chechens, from the youngest to the oldest, was stronger than hate. It was not hatred, for they did not regard those Russian dogs as human beings, but it was such repulsion, disgust, and perplexity at the senseless cruelty of these creatures, that the desire to exterminate them -- like the desire to exterminate rats, poisonous spiders, or wolves -- was as natural an instinct as that of self-preservation.

Russians are right when they are claiming that they are a country of ancient traditions. I'm quite sure we could trace this kind of tradition even further back in time, maybe all the way to the Golden Horde.

Soldiers of Afghan War (Russian Language) ↩︎
Haji Murad by Leo Tolstoy, Chapter XVII ↩︎
village ↩︎
house ↩︎

On Small Propaganda Tricks

Fri, 07 Jul 2023 24:00:00 GMT

The Inspiration

I had a short discussion on Mastodon today that started with this post:

Since this was a stone thrown at Ukraine I had to participate.

But this blog post and this blog is not about Ukraine but about thinking, so let's look at this at a slightly different angle, which does not require us to take sides in the immediate discussion about Ukraine, Canadian aid or land ownership, but rather explains a trick that is used by propagandists all over the world so much, that it's probably one of the oldest and most used in the book. It's also one of the most effective.

If you read the post again and ask yourself: what is this about? The answer is obvious: it's about the impact of some Canadian aid program on land privatization in Ukraine. Personally, I have no idea what aid program he's referring to. But that's not the point. And it's also not the point of this "toot" (as they call posts on Mastodon).

The Distraction

You see, the reference to the Canadian aid program is a distraction. As any illusionist would tell you, in order to pull off a trick you need to distract viewers attention to a place where nothing is actually happening, while you do your thing in another place altogether.

Frankly, most people don't care about the Canadian aid to Ukraine and even it's impact on Ukrainian land ownership. But even if they do, they'll either agree or disagree with it, and that would mean they got distracted.

The Trick

The real trick that the author wants you to just not pay attention to, and therefore accept without critical evaluation, is in the word coup.

You see, we don't call a positive political event a coup.

coup a sudden decisive exercise of force in politics and especially the violent overthrow or alteration of an existing government by a small group (Merriam-Webster)

Sudden^[1], decisive, violent overthrow by a small group of people^[2]. Also violent, apparently. There is also the emotional attitude that the word carries. A coup is something planned behind closed doors and executed by violent people in palaces. It's something that happens in countries you wouldn't want to visit even in the best of days.

So while the poster distracts your attention by seemingly talking about Canandian aid, he is in fact smuggling a very emotionally charged and negative description to the events in Ukraine into your mind. With a single four-letter word. Not bad.

Now, you have the full right to agree or disagree with his description, but if you want to be thinking critically you need to notice it and ask yourself: wait a moment, do I actually agree that it was a coup and not a revolution, a peaceful protest, a democratic protest, an act of direct democracy by the people?

Maybe you'll need to do some reading, maybe you're just not interested. But if you noticed it - you didn't get tricked.

As I said before this trick is extremely effective and used a lot both in print and during speeches and debates. Now you know about it.

UPDATE

After I published this post and got some comments on it, I have managed to find an even better example of the same trick by the same poster.

This example is even better than the first one, so I had to update the post. Look what's going on here:

There is a clear double standard between the media hysteria over alleged Russian atrocities in Ukraine and the silence over the rampages by Israeli troops and settlers on the occupied West Bank.

Take a moment yourself and try to point out, where is the distraction and where is the trick?

So the distraction is the whole part about media having double standards, and the trick, as always is in details. You see, while you're thinking about Israel and your position on what's going on there the poster is smuggling two very charged words: hysteria and alleged.

Neat, ha? If this wasn't propaganda I would almost admire the cunning and elegance. So the media reaction to the largest war since WW2 with literally thousands over thousands of documented war crimes is called "hysteria" and the crimes themselves are "alleged", unproven, maybe non-existent.

As I said before, your opinion on the subject is your business. But for the sake of critical thinking you have to notice these words being smuggled while you're distracted.

Euromaidan lasted 3 months and 1 day. Does this count as sudden? Wiki ↩︎
Does this group of people seem small and violent? Five hundered thousand Ukrainians singing national anthem during the 2013 revolution YouTube ↩︎

Instant offline emails on Mac with goimapnotify, mbsync and mu

Tue, 04 Jul 2023 24:00:00 GMT

Intro

I have spent a few hours today making sure that my emails get delivered to my offline inbox as soon as they appear on the server, and that this happens for each of my email accounts.

Tools

I assume that you already have your favorite offline email management tool (mu, notmuch etc.) set up and your emails are synced with something like mbsync (isync). So you've got the basics covered and are ready for the advanced stuff.

If you're not there yet, here are a couple of great articles to help you get started in different ways:

Mailboxes

For the sake of this tutorial let's assume that you have a .mbsyncrc file with two mailboxes set up: work and private. This means that you can get all mail from the server using mbsync -a or selectively sync just work or private with mbsync work and mbsync private.

At the moment you either start the sync manually, or more probably have something like a homebrew service for isync running and checking for emails every few minutes.

We're going to make this experience as seamless as it is on the smartphones with new emails appearing in your inbox as soon as they hit the server.

Setup

First let's install goimapnotify. It's not available on brew and will require golang to be installed so:

brew install golang
go install gitlab.com/shackra/goimapnotify@latest
Add the target folder for go installs to PATH, normally its ~/go/bin, so add this to .zshrc:

export PATH=$HOME/go/bin:$PATH

Ok, the easy part is over. Now let's make config files.

Configuration

For some unknown reason goimapnotify thinks that it's config files should have a .conf extension, even though the content is simple json. We will not follow this strange pattern, and will create two json config files work.json and private.json.

Let's assume that your work email is on Gmail, and your private is on Protonmail (as it should be, preferably with a custom domain name, so that you could leave for another provider if you wish).

work.json

The simplest version of work.json for gmail would look like this:

{
    "host": "imap.gmail.com",
    "port": 993,
    "tls": true,
    "username": "your.work.email@gmail.com`,
    "password": "YOUR_PASSWORD",
    "onNewMail": "mbsync work",
    "onNewMailPost": "mu index --lazy-check",
    "boxes": ["INBOX"],
    "wait": 1
}

In this file we instruct goimapnotify to connect to our work Gmail inbox and wait for new messages. As soon as a new message hits, we wait 1 second and then run the onNewMail command mbsync work. This does the normal run of downloading new messages.

Once this is done we run a onNewMailPost command to index new emails.

If you want this to be more secure, you can substitute getting your password with a command like pass or op (1Password CLI):

{
    "host": "imap.gmail.com",
    "port": 993,
    "tls": true,
    "username": "your.work.email@gmail.com`,
    "passwordCmd": "pass email/work", // [!code focus]
    "onNewMail": "mbsync work",
    "onNewMailPost": "mu index --lazy-check",
    "boxes": ["INBOX"],
    "wait": 1
}

Instead of password we provide a passwordCmd to get the password from pass. We can also do the same for the username, substituting username with usernameCmd and even with the host to hostCmd. For the most paranoid.

private.json

With Protonmail you would need to set up a Protonmail Bridge, so the config would look like this:

{
    "host": "127.0.0.1",
    "port": 1143,
    "tls": false,
    "username": "your.private.email@proton.me",
    "passwordCmd": "pass email/private",
    "onNewMail": "mbsync private",
    "onNewMailPost": "mu index --lazy-check",
    "boxes": ["INBOX"],
    "wait": 10
}

So, now you're ready to test it out. Put these two config files anywhere, for example into ~/.config/goimapnotify/ and test out your Work email integration with:

goimapnotify -conf ~/.config/goimapnotify/work.json -debug

The -debug would make sure you get enough log output to understand that everything works.

Now all you need to do is send an email to your work email and watch the logs. If everything works fine, after the email appears in your Gmail inbox you should get a log message, and then mbsync and the mu will kick in, and email should be readily available in your offline email client of choice.

Launch as Startup

If everything works you're ready for the last step - make all of this launch at startup. On MacOS we need to use launchd to run things at startup, and getting those pesky plist files is always a hassle. So in case you need to debug use something nice like LaunchControl, I used the free version. There is also a very neat online plist generator launched., I haven't used it but it can definitely come in handy.

For work create a file called com.example.workemail.plist and put it to ~/Library/LaunchAgents:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.example.workemail.plist</string>
    <key>ProgramArguments</key>
    <array>
         <string>/Users/USERNAME/go/bin/goimapnotify</string>
         <string>-conf</string>
         <string>/Users/USERNAME/.config/goimapnotify/work.json</string>
    </array>
    <key>KeepAlive</key>
    <true/>
    <key>RunAtLoad</key>
    <true />
    <key>StandardErrorPath</key>
    <string>/Users/USERNAME/Library/Logs/CheckMailBlaster.err</string>
    <key>StandardOutPath</key>
    <string>/Users/USERNAME/Library/Logs/CheckMailBlaster.log</string>
    <key>EnvironmentVariables</key>
        <dict>
           <key>PATH</key>
           <string>/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin</string>
        </dict>
</dict>
</plist>

Replace USERNAME with your user name.

The most tricky part that took a good hour to debug was figuring out that you need to provide the PATH variable to the running process, as it doesn't have access to the system wide one. Until I did, goimapnotify would start and connect normally, and once the new email hit I got an error on the mbsync step.

So, as I said this simple file took two hours of debugging, so say thank you and create similar file for private email like com.example.privateemail.plist in the same directory.

Now all that's left is launch:

launchctl load ~/Library/LaunchAgents/com.example.workemail.plist
launchctl load ~/Library/LaunchAgents/com.example.privateemail.plist

Make sure that they're running with

launchctl list | grep com.example

Or better yet use LaunchControl to monitor their status. If everything worked you should get the services started as soon as you log in, and the mail will appear in your inbox instantly.

Please note, that the sync will start only when a new email appears, so if your computer was off for the night and you turn it on, the syncing will not begin until the first new email that day. To avoid that you can create a similar plist that launches once and runs

mbsync -a

I leave that as an exercise for the reader.

Manage git hooks with babashka tasks

Wed, 30 Nov 2022 24:00:00 GMT

Git hooks are scripts that Git executes before or after one of the following events: commit, push, and receive.

By default a git repository comes with a bunch of sample hooks, located in .git/hooks directory. Let's look at a pre-commit.sample hook. This is a 50 line script that checks, that the files you're committing do not contain any non-ascii characters. Sound like a good idea, but fifty lines of bash don't look friendly (don't read it, just take a glance).

#!/bin/sh
#
# An example hook script to verify what is about to be committed.
# Called by "git commit" with no arguments.  The hook should
# exit with non-zero status after issuing an appropriate message if
# it wants to stop the commit.
#
# To enable this hook, rename this file to "pre-commit".

if git rev-parse --verify HEAD >/dev/null 2>&1
then
	against=HEAD
else
	# Initial commit: diff against an empty tree object
	against=$(git hash-object -t tree /dev/null)
fi

# If you want to allow non-ASCII filenames set this variable to true.
allownonascii=$(git config --type=bool hooks.allownonascii)

# Redirect output to stderr.
exec 1>&2

# Cross platform projects tend to avoid non-ASCII filenames; prevent
# them from being added to the repository. We exploit the fact that the
# printable range starts at the space character and ends with tilde.
if [ "$allownonascii" != "true" ] &&
	# Note that the use of brackets around a tr range is ok here, (it's
	# even required, for portability to Solaris 10's /usr/bin/tr), since
	# the square bracket bytes happen to fall in the designated range.
	test $(git diff --cached --name-only --diff-filter=A -z $against |
	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
then
	cat <<\EOF
Error: Attempt to add a non-ASCII file name.

This can cause problems if you want to work with people on other platforms.

To be portable it is advisable to rename the file.

If you know what you are doing you can disable this check using:

  git config hooks.allownonascii true
EOF
	exit 1
fi

# If there are whitespace errors, print the offending file names and fail.
exec git diff-index --check --cached $against --

And if you want to add more things to the pre-commit hook, like formatting all the modified files with a code formatter, you'd need to append to it, making your life even harder. After all, who wants to code with bash?

So, let's replace all this bash with babashka.

Project Setup

I'll assume we're working within a Clojure repo, but in fact this doesn't really matter. Babashka is a standalone binary that will work for a project in any language.

Install babashka. For Mac OS and brew just run:

brew install borkdude/brew/babashka

For everything else follow official installation instructions.

Create a bb.edn file and a bb folder.

Babashka Tasks

Babashka comes with an amazing and useful task runner, which aims to replace Makefile, Justfile, npm scripts or lein and for us it has already replaced all of these. So we'll create our first task.

For those of you who have never dealt with babashka tasks, let's make a really simple one. Put this in your bb.edn:

{:paths ["bb"]
 :tasks
 {hello {:doc "Say hello"
         :task (println "Hello from babashka tasks!")}}}

Now if you run bb tasks from the root of your project babashka will list all available tasks:

$ bb tasks
The following tasks are available:

hello Say hello

And you already now what running bb hello will do:

$ bb hello
Hello from babashka tasks!

So now that we know the tasks basics let's get back to hooks.

Basic Hooks Script

Create bb/git_hooks.clj and open it in your editor of choice. And since it's a babashka script and in the wonderful world of Clojure we practice interactive (or REPL-driven) development, you can fire up a babashka REPL and play with the code while working.

Let's start with moving our hello task to this file to understand how this works. Put this in your bb/git_hooks.clj:

;; bb/git_hooks.clj
(ns git-hooks)

(defn hello [& args]
  (println "Hello! My args are:" args))

Let's change the bb.edn file to use the hello function from the git-hooks namespace.

;; bb.edn
{:paths ["bb"]
 :tasks
 {hello {:doc "Say hello"
         :requires ([git-hooks :as gh])
         :task (apply gh/hello *command-line-args*)}}}

There are a few important things to note. First the :requires line:

;; bb.edn
{:paths ["bb"]
 :tasks
 {hello {:doc "Say hello"
         :requires ([git-hooks :as gh])  // [!code focus]
         :task (apply gh/hello *command-line-args*)}}}

It is slightly different from the traditional Clojure's :require form (note the plural), but the idea is the same: we defined the source paths in the first line, and now we can require any namespace from it.

Second, note how we ran the task now:

;; bb.edn
{:paths ["bb"]
 :tasks
 {hello {:doc "Say hello"
         :requires ([git-hooks :as gh])
         :task (apply gh/hello *command-line-args*)}}}  // [!code focus]

If we didn't want to pass command line arguments into our function, we could just write:

:task gh/hello

And if we do, babashka gives us access to the args with *command-line-args* variable which we can pass or apply to our function. Let's try it out:

$ bb hello world
Hello! My args are: (world)

Setting up Hooks

Since there are various tasks we'll be executing and it's quite trivial to accept commands in Clojure, let's make one task called hooks which will accept and run commands, like pre-commit, pre-push, install etc.

Let's edit bb/git_hooks.clj like this:

;; bb/git_hooks.clj
(ns git-hooks)

(defmulti hooks (fn [& args] (first args)))

(defmethod hooks "pre-commit" [& _]
  (println "Running pre-commit hook"))

(defmethod hooks :default [& args]
  (println "Unknown command:" (first args)))

We're using a standard polymorphism tool in clojure — multimethod, which will treat the first command line argument as command.

And bb.edn:

;; bb.edn
{:paths ["bb"]
 :tasks
 {hooks {:doc "Hook related commands"
         :requires ([git-hooks :as gh])
         :task (apply gh/hello *command-line-args*)}}}  // [!code --]
         :task (apply gh/hooks *command-line-args*)}}}  // [!code ++]

Not much changed here, and in fact we will not need to edit bb.edn any more, since this already has us covered for implementing hooks of any complexity. We just changed the name of the function we're calling.

Installing Hooks (manually)

We already have the simplest possible hook — our hooks function when called with pre-commit argument prints "Running pre-commit hook":

$ bb hooks pre-commit
Running pre-commit hook

In order for the git to run our function each time we commit anything, let's add a following .git/hooks/pre-commit file:

#!/bin/sh

bb hooks pre-commit

And make it executable:

$ chmod +x .git/hooks/pre-commit

Now if we run git add and git commit we should see the printed text:

$ git add .
$ git commit -m "Test simple hook"
Running pre-commit hook
[master (root-commit) c7dc8e4] Test simple hook
 2 files changed, 16 insertions(+)
 create mode 100644 bb.edn
 create mode 100644 bb/git_hooks.clj

And indeed, here it is.

Once we have "installed" the hook this way, we can now modify it's behavior in bb/git_hooks.clj. But before giving a couple of examples of doing that, let's automate the boring part: installing hooks.

Installing Hooks (bb task)

Let's add a couple of helper functions and add an install implementation to our hooks multimethod:

;; bb/git_hooks.clj
(ns git-hooks
  (:require [babashka.fs :as fs]))

(defn hook-text
  [hook]
  (format "#!/bin/sh
# Installed by babashka task on %s

bb hooks %s" (java.util.Date.) hook))

(defn spit-hook
  [hook]
  (println "Installing hook: " hook)
  (let [file (str ".git/hooks/" hook)]
    (spit file (hook-text hook))
    (fs/set-posix-file-permissions file "rwx------")
    (assert (fs/executable? file))))

(defmulti hooks (fn [& args] (first args)))

(defmethod hooks "install" [& _]
  (spit-hook "pre-commit"))

(defmethod hooks "pre-commit" [& _]
  (println "Running pre-commit hook"))

(defmethod hooks :default [& args]
  (println "Unknown command:" (first args)))

Let's go over this:

(defn hook-text
  [hook]
  (format "#!/bin/sh
# Installed by babashka task on %s

bb hooks %s" (java.util.Date.) hook))

This is pretty straightforward. It creates a bash script string for a hook of our choice and timestamps it.

(defn spit-hook
  [hook]
  (println "Installing hook: " hook)
  (let [file (str ".git/hooks/" hook)]
    (spit file (hook-text hook))
    (fs/set-posix-file-permissions file "rwx------")
    (assert (fs/executable? file))))

This part is slightly more interesting. It writes the output of hook-text into the actual hook and uses babashka.fs library to make it executable.

Let's run bb hooks install and check that the hook file has in fact changed:

$ bb hooks install
Installing hook:  pre-commit
$ cat .git/hooks/pre-commit
#!/bin/sh
# Installed by babashka task on Wed Nov 30 01:06:37 WET 2022

bb hooks pre-commit

Despite being so simple this little trick gives us an enormous advantage. You see, git hooks are user local. If we create a pre-commit hook on our machine it will stay on our machine for security reasons.

So if we want our entire team to use the same hooks, normally we would need to make sure that they manually implement same hooks as us. The babashka way let's us simply mention in our documentation that you need to run bb hooks install after checking out the project and we're done.

Listing Changed Files

After installing hooks this way we will never have to open the .git/hooks directory or edit bash files. We control every aspect of our hooks from within the bb/git_hooks.clj files, and can use babashka and Clojure to implement hooks of any complexity.

Before we move on to our first real hook, we need one last helper function:

;; bb/git_hooks.clj
(ns git-hooks
  (:require [babashka.fs :as fs]
            [clojure.string :as str]
            [clojure.java.shell :refer [sh]]))

(defn changed-files []
  (->> (sh "git" "diff" "--name-only" "--cached" "--diff-filter=ACM")
       :out
       str/split-lines
       (filter seq)
       seq))
...

For many real-life tasks (think code formatting), running something like cljstyle over your entire code base might take too much time. So to optimize that you'd want to only run it over staged files. That's where our changed-files function comes in. It returns a list of staged files, excluding any deleted files — ready to be passed to whatever logic you want to run over them.

"Real" Hook

Let's add a step to our pre-commit hook that formats all staged file using cljstyle:

(defmethod hooks "pre-commit" [& _]
  (println "Running pre-commit hook")
  (when-let [files (changed-files)]
    (apply sh "cljstyle" "fix" files)))

Honestly, I strongly prefer this to any bash. And if you want to add any more logic to be performed over the changed files, you can do it right in the pre-commit implementation of the hooks function.

In order to make the formatting hook production ready we need to make sure it's only run over Clojure files. Let's make another predicated for that:

(def extensions #{"clj" "cljx" "cljc" "cljs" "edn"})
(defn clj?
  [s]
  (when s
    (let [extension (last (str/split s #"\."))]
      (extensions extension))))

And put it all together:

;; bb/git_hooks.clj
(ns git-hooks
  (:require [babashka.fs :as fs]
            [clojure.string :as str]
            [clojure.java.shell :refer [sh]]))

(defn changed-files []
  (->> (sh "git" "diff" "--name-only" "--cached" "--diff-filter=ACM")
       :out
       str/split-lines
       (filter seq)
       seq))

(def extensions #{"clj" "cljx" "cljc" "cljs" "edn"})

(defn clj?
  [s]
  (when s
    (let [extension (last (str/split s #"\."))]
      (extensions extension))))

(defn hook-text
  [hook]
  (format "#!/bin/sh
# Installed by babashka task on %s

bb hooks %s" (java.util.Date.) hook))

(defn spit-hook
  [hook]
  (println "Installing hook: " hook)
  (let [file (str ".git/hooks/" hook)]
    (spit file (hook-text hook))
    (fs/set-posix-file-permissions file "rwx------")
    (assert (fs/executable? file))))

(defmulti hooks (fn [& args] (first args)))

(defmethod hooks "install" [& _]
  (spit-hook "pre-commit"))

(defmethod hooks "pre-commit" [& _]
  (println "Running pre-commit hook")
  (when-let [files (changed-files)]
    (apply sh "cljstyle" "fix" (filter clj? files))))

(defmethod hooks :default [& args]
  (println "Unknown command:" (first args)))

Now each time we run git commit every Clojure file will be formatted with cljstyle.

Now you can build from here, for example creating a pre-push hook that will not allow pushing if clj-kondo finds any errors. Or building anything that you want with babashka.

All without writing a single line of bash.

Elon Musk and the Magic of Names

Tue, 04 Oct 2022 24:00:00 GMT

Yesterday a strange thing happened. You have probably seen it:

I'm not going to concentrate on all the ways posting this was wrong. I expect there will be a shit storm strong enough without my five cents. In the spirit of this blog I'm more interested in the questions relating to thinking and knowledge. And there's an obvious one.

How do we know that we really know what we think we know?

Wow that's a stunning example of a well-formulated question right there.

I admit, I'm kinda using Elon Musk here as a screaming example of publicly talking about things you have no clue about. But we're all guilty at times of doing the same. Even if we're not public.

But let's keep using him as an example. There must be some foundation under his opinion about Crimea: after all, he confidently states that:

Crimea formally part of Russia, as it has been since 1783 (until Khrushchev’s mistake).

And there lies the trap that most people will fall into. They will try fact checking this statement, reading the Wiki article on Crimea, trying to figure out was it really formally a part of Russia. Reading and arguing about how Crimean Khanate was conquered and if Crimea wanted to be a part of Russia.

And they will totally miss the elephant in the room. The "Russia" he talks about doesn't exist. And it didn't exist for over a century.

Wait what?

This little thought was nagging me for a long time, maybe 10 or even 20 years, and I could never put my finger exactly on it. Until I did.

Being Ukrainian, for me this was kind of obvious^[1] on an intuitive level. But until today I didn't see it for what it was — the most ingenious piece of Russian propaganda.

It's all in the name

Long time ago there was a country called "Russia". Well, maybe there was such country, it's hard to tell by now, after rewriting history so many times. But there definitely was a country called Russian Empire, and we can tell exactly when it started.

The term and the entire ideology was coined by a Ukrainian^[2] scholar Theophan Prokopovich (ukr. Феофан Прокопович), a very educated guy lacking any moral compass. After Peter I tried destroying Kyiv Mohyla Academy, the only real university in the region of that time, he promoted Theophan to some important role in Saint Petersburg. There he coined the whole concept of Russian Empire, following a good European tradition of claiming to be the Third Rome^[3].

In any case, in 1721 he renamed the Tsardom of Russia into Russian Empire, and that's when the country officially started. And that country was normally referred to as Russia in the West. That's important.

Before World War I it was a pretty big country. As Elon Musk says, Crimea was formally it's part. As were other nice places, like Poland, Finland and all the Baltic states.

Right until it stopped existing.

The "Great October Revolution"

You need to understand, that I'm doing this as quickly as I can before I get you bored. We're almost there.

In 1917 after a series of revolutions caused by the terrible decision to participate in the Great War, there finally seemed to be a clear revolutionary winner — the Bolshevik Party, which later became the Communist Party.

And they wanted nothing to do with the former Imperial past. They renamed the country into Union of Soviet Socialist Republics, also known as the Soviet Union. And that was the country I was born in.

Some places got lucky and broke off early, when this abomination of a state was just forming: like Finland. Others tried, but didn't succeed, like Ukraine^[4].

But even those places that didn't succeed, were not part of Russia. They were part of the Soviet Union. Multinational. Multicultural. Calling themselves "soviet people". Not "Russians".

USSR was a scary country with a scary ideology, and we're all lucky it didn't survive the Cold War. But until it's later days that country had principles. I don't agree with it's ideology, but it had one. I don't agree with the future it wanted to build for the humanity, but it was looking into the future.

That country fought in World War II and a bunch of other wars. That country was one of the founding states of United Nations and a permanent member of the UN Security Council.

Right until it stopped existing in 1991.

Devil's work

The Devil’s cleverest wile is to make men believe that he does not exist. -- Charles Baudelaire

Modern day Russia is like that, but it tries to convince the world (and itself), that it's somehow, magically, the same country as USSR and Russian Empire. The whole idea behind rashism is trying to bring back the past, not to build some brighter version of the future (even if it doesn't seem brighter to everybody else, like in the case of the USSR).

And it's not the first time something like this happens in a dictatorship. Mussolini used to address the Italians as Romans, and insisted that his Italy was magically the same country as the Roman Empire.

So saying that Crimea was part of Russia, and should be left to Russia is like saying that Greece was a part of the Roman Empire, and should be left to Italy.

And the only reason it doesn't sound absurd is because during the Soviet times we kept calling the country "Russia".

Returning to the original question

So how do we know that we really know what we think we know? I'm afraid this question is so big, that it's impossible to cover in an essay. But there are some tricks we can use:

Look for alternative points of view and alternative sources

And by point of view I don't just mean "opinions", but also other angles to look at a the subject. Because if the subject is even a slightly bit controversial (and most interesting subjects are), and you only used one source — by definition you only heard one side of the story.

Question fundamentals

Try questioning the most fundamental parts of the subject. Like with the Musks tweet the fundamental part was not whether Crimea is or is not part of Russia, but in fact whether the "Russia" he talks about even exists.

I hope you enjoyed the ride.

If something seems "obvious" it's a true sign that almost everybody else sees it differently ↩︎
Fate is a bitch ↩︎
Read up on translatio imperii, but read something good ↩︎
Read up on Ukrainians People's Republic ↩︎

Why write?

Tue, 20 Sep 2022 24:00:00 GMT

Writing is a tool. And as any good tool it can be used for many things. Sharing information. Telling stories. Messaging. Influencing people to make the choice you want them to make. All these uses were clear to me for a long time, and they all were pretty self-explanatory.

There was one special use though, that I was wondering about for a long time.

Writing helps you think.

A couple of days ago I was flying from Lisbon to Krakow, first part of my journey to my home in Ukraine (why go there during the war is another story).

Right before the take off I stumbled upon an essay by Paul Graham called, ironically, The Age of the Essay. As brilliant people often do, he put in words precisely the things I felt for a long time.

I recommend you read his original piece, as he did a great job about describing the history and the essence of writing essays. But I will quote one thing:

In a real essay you're writing for yourself. You're thinking out loud.

But not quite. Just as inviting people over forces you to clean up your apartment, writing something that other people will read forces you to think well.

And this really stroke a note inside. I knew for a long time that writing helps me think. I even joked sometimes that you need to sit down and write on the subject to find out what your real opinion is.

But reading Graham's piece changed two things:

This kind of writing now had a name. Essays.
It gave me a good reason to publish what I write.

And now you're here. Reading.

Thank you for giving me a reason to clean up my mess!