EDIT: I’ve had some feedback from HN readers, and I’ve learned some interesting things since writing this post!
For one, after this whole journey I thought that surely it is easy enough to type in answers on Anki, and indeed it is. In the card’s template, you can add an entry {type:FieldName} to the front, where you are asked ot type in whatever FieldName is. So in my “Frequency Dictionary of Dutch” deck, I’ve added type:Definition.
Secondly, I actually read the manual for Anki, and they have a great explanation of what the Again / Hard / Good / Easy buttons actually do to the underlying repetition model. What I liked about Genius was how straightforward it was to understand why you’re seeing or not something during a review session.
Finally the post had some typos, and a couple of errors. Thanks to aaronbrethorst for pointing out that + and - are for instance, and class methods, not public/private.
In my recent foray into learning Dutch for my relocation to the Netherlands – I’m sure there’ll be much to blog about – I fell victim to the siren song of the Green Owl again.
It’s too tempting - you get showered with instant feedback, encouragement in-app rewards, social stuff etc. To be fair it is fun, and you really feel that you’re doing something useful.
…except.
I last used it in earnest it to ‘learn’ German before a trip to Berlin. I racked up a 150+ day streak or something nuts like that, a good 15 mins per day which they deem pretty high, and then turned up utterly unable to speak or read anything of actual utility
die Frau ist kein Klavier
am Dienstag spreche ich nicht mit dem Apfel
Now I don’t think it was always like this, and really it’s for another blog post to enumerate the all of the ways it’s been enshittified but suffice to say it’s just not for me anymore.
On the other end of this gamification spectrum is just hard flashcards. Learn the thing on the other side of this card. Your reward is the number of stuff you’ve learned, and if you ‘break your streak’, that’s on you - you’re just not learning anything.
Now, people swear by Anki.
I’ve friends who’ve learned all the world flags, taught themselves to recognise basically any painter by their style etc. Really cool stuff. I think though, for whatever way I ingest language and information, it’s not so good for me.
Specifically I think I’m missing clear right/wrong feedback (rather than judging if I was ‘good’ or ‘bad’ at remembering it), as well as the mechanics of actually having to type out the answer.
In school and univeristy I found that unless I was actually taking notes, and actually writing text, or even typing, I was just not engaging enough.
And so, when flipping over Anki cards and saying them in my head, it just sort of feels like temporarily stimulation of short-term memory.
Despite the spaced repetition, nothing seems to go in, and so I’ve just not been able to build a good habit with it.
(I think there are cards where you have to type the answer in, but truth be told I haven’t really dug into that)
Now though this brings me to my holy grail, white whale app, from years gone by.
Genius was a spaced repetition app originally written by John R Chang for his own needs. It uses a comparatively simple (to Anki) but still very effective spaced repetition app for learning flashcard-like associations.
And, it was so simple. You have 2 columns to enter the things you want to learn (the cue), and you’re quizzed on them (the answer).
Plus, it had just the right amount of instant-gratification, reward conditioning sounds in the form of the OS X Basso, Blow, Funk.
Alas, development stopped sometime around 2008, and despite an impressive run, it no longer runs on macOS:
/Volumes/Genius/Genius.app/Contents/MacOS
❯ file Genius
Genius: Mach-O universal binary with 2 architectures: [ppc:
- Mach-O executable ppc] [i386:
- Mach-O executable i386]
Genius (for architecture ppc): Mach-O executable ppc
Genius (for architecture i386): Mach-O executable i386
Yes, PowerPC, and i386 (32 bit) only. We’re a few architectures past that!
As an aside, I’ve been really impressed by some recent really cool software/tech conservation, poeple are doing.
See stuff like MattKC and co’s Lego Island decompilation where they have reverse-engineered and entirely reimplemented whole swathes of the game. Or the Frogger source code recovery
Or on the hardware side, the saving of the world’s largest CRT TV from a closing-down soba restaurant in Osaka (this is seriously a good watch).
Anyway I figured, if feckin Lego Island can be decompiled, and people can save code from ancient proprietary magnetic tapes, surely it’s not beyond the wit of man, me, to get Genius to work again.
Maybe I can be that developer :)
The homepage is https://genius.sourceforge.net. With some clicking about, you’ll find the link to the source code, an SVN repo. I’d only ever heard of SVN from my elders in university - something about locking, a ‘check out’ being an actual ‘check out’ as one aquires an exclusive lock on a library book.
I’m not interested in plumbing those depths, but luckily git-svn is.
So after much waiting, I ended up with a neat git repo. It’s jarring to pop open a familiar git log and see commits from 2004:
commit 5d5624365ab06b08bb83257e78d1bc44bbca7664
Author: jrc <jrc@f73e0bdd-8638-0410-8bb3-c52e70a1423d>
Date: Sat Nov 6 02:29:42 2004 +0000
loc 1
commit a2045bf7f2d5ed93f73893edce72665ea260453e
Author: jrc <jrc@f73e0bdd-8638-0410-8bb3-c52e70a1423d>
Date: Sat Nov 6 02:28:42 2004 +0000
*** empty log message ***
commit 1d9e71e3fafe91d182a244b3bf5fc1173348dfcb
Author: jrc <jrc@f73e0bdd-8638-0410-8bb3-c52e70a1423d>
Date: Tue Oct 19 21:53:33 2004 +0000
This commit was generated by cvs2svn to compensate for changes in r2,
which included commits to RCS files with non-trunk default branches.
commit 62485d30ab237f05d04e2791a9e6871b9adbf701
Author: (no author) <(no author)@f73e0bdd-8638-0410-8bb3-c52e70a1423d>
Date: Tue Oct 19 21:53:33 2004 +0000
New repository initialized by cvs2svn.
I love how everything repeats itself. I wonder what was in the CVS source.
As it turns out, it was surprisingly easy to get the project to build!
The .xcodeproj format still seems to be entirely forwards-compatible, and it opened up completely fine on the latest developer tools, on my arm64 macbook.
Building failed, as it was unable to locate the old OS X 10.4 SDK it was hard-coded to require.
But changing this to the latest tooling let the obj-c compiler actually run, with a compiler error!
GeniusAssociationEnumerator.m:265:87 Incompatible function pointer types sending
'int (id, id, void *)' to parameter of type
'NSInteger (* _Nonnull)(id _Nonnull, id _Nonnull, void * _Nullable)'
(aka 'long (*)(id _Nonnull, id _Nonnull, void * _Nullable)')
Looks like type checking got a little bit more strict.
A single line change fixed the build:
//! randomly returns NSOrderedAscending or NSOrderedDescending
-int RandomSortFunction(id object1, id object2, void * context)
+NSComparisonResult RandomSortFunction(id object1, id object2, void * context)
{
BOOL x = random() & 0x1;
return (x ? NSOrderedAscending : NSOrderedDescending);
As an aside, surely it’s really confusing as an Objective-C developer reading diffs when it uses + and - to denote class/instance methods?
…and it ACTUALLY BUILT.
It looks a bit janky, but it works!
The next hurdle was getting Xcode to read the old nib files for the UI. I’ve admittedly little idea how it works, but they seem so old that even Xcode can’t convert them. Fortunately there is ibtool, which has an --upgrade option to replace them.
After a little bit of messing about in Interface Builder, upscaling the icons, and fixing some text clipping, we get a fairly snazzy, modern looking macOS app! And it’s completely functional, fully compatible with the original .genius card decks I created years ago.
Projects like this are certainly fun, and valuable in their own right. I’ve learned a relative ton (compared to my zero knowledge) about mac development, took a nice trip down memory lane with the different architectures, etc.
However ultimately Genius was written to aid memorisation, and now I’m happily using it to do just that, just as I did back in 2008!
You can browse the updated source code at https://github.com/shawa/genius.
]]>In school, I had always found the months of the year, and the seasons to be somewhat arbitrary. Growing up in Ireland, that calendars are quite arbitrary was somewhat obvious - most of the media we consumed (from Britain and the USA) was from places where the first day of the week is Monday, whilst we were always taught that Dé Domhnaigh, Sunday, was the first day of the week.
It was only in university when we learned the agony of programming dates and times that I actually appreciated how utterly arbitrary the Gregorian calendar is.
Take how September, October, November, December have latin-name prefixes (7, 8, 9, 10…), whilst they actually seem to fall two months too late.
Supposedly this was because emperors Julius and Augustus wanted some calendar action, and so they squeezed in some months of their own mid year (presumably in the summer months, so people would associate them with good weather and jet-setting abroad).
So, calendars are somewhat arbitrary - we have to mark out time somehow, and that’s inevitably going to lead to having to simply make some choices.
Similar to the days of the week, the seasons in Ireland are shifted somewhat. The traditional calendar has Spring, or Earrach start in February, rather than March, like in Britain and I suppose the rest of the world.
Wikipedia has a great graphic showing the structure of the ancient Irish calendar, which is, on the contrary, entirely rooted in the solar cycle. Festivals fall at the midpoint between a solstice and an equinox, and are celebrated to mark the changing of the Seasons.
I liked this graphic so much that I wanted to animate my own. The below graphic is the essence of that same SVG, but drawn with the Canvas API.
The quadrants are the seasons, the label in the middle are their names. and their start and end points mark the changes of each season.
The labels in the middle show the season names, whilst the dotted lines mark the solar events marking their midpoints.
There is one more dotted line which today is colliding with IMBOLC’s line. This will update on page-load to the current day, marking where we are with respect to the seasons.
I quite enjoyed cobbling this together and re-learning about the seasons.
I appreciate the structure of it and how it simply relates to the earth and the sun. Now, with climate change, God knows how the real seasons are going to drift from how they were for year.
Sadly maybe this will become another calendar that looks completely arbitrary, but for the moment it’s nice to pause and appreciate the intuitive pragmatism of older ways. Now, there is an entire world, dimension even of exploration into the history of ancient Irish festivals which I don’t have the confidence to explain without completely butchering it.
I’d sooner recommend you do a bit of searching. Manchán Magan has a great recording on Geata Arts chatting about some of the oldest customs that could be gathered from community elders:
Wishing all a nice bright Earrach!
]]>I’m enjoying the longer form concept of the blog. It’s making me realise how since school and university how little time I actually spend putting pen to paper and thinking and writing about something for more than five seconds. ‘m also finding myself more inclined to spend commuting time a little bit more mindfully and pick up notes and jot something down rather than, say, desperately scroll on patchy phone signal.
All this said though, there is some role still for shorter form micro blogging. The halcyon days of the golden era of Irish Twitter, of bread flying off the shelves during a storm, yer man doing ketamaine while serving drinks to the president, the Luas is free…
Twitter’s fate is sealed of course, and I have no interest in throwing my wailings about what’s going on with it, and what that represents into the chasm of gloom. All I know is I want out, so I’ve archived and deleted my account.
That brings us to what I’m doing in its place. Bluesky is cool but it’s still another enclosed platform. I’m sure ActivityPub or the AT protocol or whatever it uses is cool and all but I’m not interested really. What I am interested in is how I can generate more pages for my website.
Enter the Web Posts. Another fine invention of andrewshaw.nl.
I have taken the liberty to reinvent and reimplement the format. Within my site’s codebase I have a bag of markdown files which all get hoovered up at page generation time. The creation time of the file is taken to be the post date, and they all get stuffed into /posts.html.
Now I don’t carry my laptop everywhere, and I can’t regenerate the site on the go, and I don’t want to turn up a whole backend to accept posts (the site is still static HTML), so instead I have a neat little workflow using iCloud and shortcuts:
This gets saved into a markdown file in my iCloud Drive, and then at generation time, these are all copied over with the rest of the posts.
For the moment I think it’s very neat. Since it’s markdown, of course I can do whatever I like and use mad formatting, gifs, iframes, whatever.
]]>Surprisingly there aren’t that many libraries for building RSS feeds for Elixir. Perhaps that’s not surprising, since it seems RSS has fallen out of favour in deference to integrated social media platforms. Alas.
But perhaps also it’s not ever been necessary. As it turns out RSS stands for “Really Simple Syndication”, and it really is, really simple.
Your RSS “feed” is an XML document, which contains a channel, with metadata, and items which are your posts.
These posts are just elements which themselves contain metadata like the title, publication date and a summary as well as an ID, so that RSS readers can detect whether it’s seen a post before (so that it can decide if it’s a brand new post, or just one which has been updated).
And as it turns out generating all this stuff with EEx is very very easy. Originally I was considering writing a library that represents feeds, channels and posts as structs, and then serialise that to XML, but as it turns out I can just generate the file directly in one shot. Seriously, this is the entire template:
<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0">
<channel>
<title>andrewshaw.nl</title>
<link>https://andrewshaw.nl</link>
<description>Andrew Shaw's personal website</description>
<language>en-ie</language>
<pubDate><%= DateTime.utc_now() |> DateTime.to_iso8601() %></pubDate>
<%= for post <- @posts do %>
<item>
<title><%= post.title %></title>
<link>https://andrewshaw.nl/blog/<%= post.slug %>.html</link>
<guid>https://andrewshaw.nl/blog/<%= post.slug %>.html</guid>
<pubDate><%= post.date %></pubDate>
<description><![CDATA[<%= post.abstract %>]]></description>
</item>
<% end %>
</channel>
</rss>
Very nice altogether!
Through all of this, I do wonder where we lost our way. You can surely design a twitter-style microblogging site purely around these dead simple XML feeds. I wonder where we would be at if this were embraced instead of closed platforms. Probably fewer users I suppose.
]]>This homepage is half in-earnest technical project and half performance art. I wanted to keep things as simple, bare-bones, and extensible as I can, and to that end I opted initially for plain HTML and CSS. It’s surprising how far default browser rendering will get you!
After a few pages worth of copy-pasting I figured something more reusable would be better, and so looked back to the days of simple PHP includes. For the equivalent, Elixir comes with EEx - Embedded Elixir for the templating of arbitrary text documents. Its efficient implementation and swappable backends is what powers Phoenix and Phoenix LiveView, and is more than suitable for my dingy needs.
In this post I’ll run through the overall structure, then break down custom sections like the blog and photo gallery. You can read this as part documentation and part tutorial. I’m not sure if I’ll bother sharing the code, but seriously, writing a static site generator is so easy that you can do pretty much all of this in an evening.
PHP, which powered my first ever one of these sort of sites, executes at response time, much like CGI. The page content is dynamically generated at runtime. To contrast, static sites are… static, so all assets are generated up front on build/deployment time. Venerable Mix tasks are used to tie the whole thing together with mix homepage.build building out all of the HTML, homepage.photos running the photo ingestion pipeline (see below) and homepage.deploy shelling out to Cloudflare’s wrangler CLI to push a new deployment up to prod.
I have one top level template, which defines the root structure of each page, that is, the actual <html> element, the <head> etc. The navbar is generated in this template, from a master list of pages.
Inside the main template is the <%= @inner_content %> include which you may recognise from Phoenix templates:
<h1>Andrew Shaw</h1>
<div id="content">
<nav>
<ul>
<%= for {page, title} <- @pages do %>
<li class="<%= if page == @current_page, do: "active", else: "" %>">
<a href="/<%= page %>.html"><%= title %> </a>
<%= if page == "blog" do %>
<img class="updated" src="/images/updated.gif" />
<% end %>
</li>
<% end %>
</ul>
<div>
<img id="audio-button" src="/images/headphone-button.gif" alt="Toggle music">
<audio id="background-music" loop>
<source src="/audio/iceland-tv-now.mp3" type="audio/mpeg">
</audio>
</div>
</nav>
<div>
<%= @inner_content %>
</div>
</div>
On build, the main Mix task expects there to be a template in lib/templates/#{page}.html.eex which it evaluates, then passes in as the inner_content assign when expanding the main template.
The blog is fed by markdown documents. I’m using MDex (which uses a cool Rust NIF to be very fast) to parse them into an AST, then YamlElixir to pull out the metadata.
Each blog post has a slug which generates the URL’s path, a date and a title, along with an abstract and fetching thumbnail to entice eager readers:
---
date: 2025-01-21
tags: [internet, elixir, mix]
slug: building-web-site
title: How the Web Site is built
abstract: A little breakdown on how this page is built and hosted
thumbnail: /images/blog/03/fs-tree.jpg
---
This homepage is half in-earnest technical project and half performance art. [...]
As a bonus, I’ve added an RSS feed, which I’ll talk about in a later post.
My photos section is deliberately very low fidelity. There’s a few reasons: For one, I still hold reservations about just lashing high res photos I’ve taken online. Anything more than an “oh that’s nice” glance, like use as a wallpaper, or printing I’d like to know about (if you’d like a higher-resolution copy of any of my photos for this purpose, please email me! Let’s talk!).
Secondly, it would be nice to hopefully make them less useful to these collect-it-all AI crawlers. Perhaps I’ll try and find some way to poison or watermark them at some point.
Mostly though, I’m prioritising the early 2000s aesthetic (hence why I’ve turned off image smoothing in the main stylesheet).
In any case there’s a simple processing pipeline; images are fed in in dated folders, then I run imagemagick over all of them to resize them down to 256 x 256 pixels, convert them to JPEG and crucially, strip out any wayward EXIF metadata, like geo-location or Facebook’s image fingerprints (most of the images are from my Instagram archive).
These then get collected into per-month gallery pages.
The only noteworthy addition to the music page is that I’m pulling in my top 100 artists from Last.fm via their developer API.
def top_artists() do
get_artists()
|> handle_response()
|> Enum.sort_by(& &1.playcount)
|> Enum.reverse()
end
Finally, I wanted something really simple, in the sense of really easy to set up. CloudFlare pages’ free tier offers unlimited bandwidth, and the bare basics like HTTPS etc. I presume it’s also pushed out to their whole edge network, so it’s good to know folks from the US, to Europe to Oceania and beyond can load my buckets of content very fast.
Deployment is as trivial as running npx wrangler pages deploy <directory with assets>. They do clever content hashing so that you only upload new versions of files that have changed.
Hosting on CloudFlare is really interesting, and I may have a separate post about the things I’ve discovered. For one, they push content out to all of their 250+ edge locations, which is a far cry from my old homepage on BlackKnight. There’s also fine grained traffic filtering and monitoring which I’ve not delved into yet. For the moment, it’s free, unlimited and easy.
And that’s about all! As I said it’s really about as simple as it gets, aside from maybe literally just using some bash scripts or something. Most of all though it’s extensible, and it’s mine.
Try making yours today!
]]>This is a collage of this fantastic time capsule of Icelandic Televison, as well as some sampling of შენ ხარ ვენახი (Thou Art a Vineyard) sung by the Rustavi Choir.
I think it captures the mood very nicely.
]]>I’m going to really heavily paraphrase, so you should read the problem spec if this is unclear. Essentially, we’re given a list of ‘page updates’, as pairs of page IDs, for example:
47|53
97|13
97|61
Which means “page 47 must occur before 53, page 97 before 13, page 97 before 61”.
The next set of inputs are proposed sets of page orderings:
97,61,53,29,13
75,29,13,97
So in line one, we place page ID 75, then page ID 47, … etc.
Part one of the problem is to find the orderings which are valid. So, given the set of rules we just ingested, check that the proposed orderings don’t break any of those rules. For example, the second one is invalid, since the last placement tells us to put page 97 after page 13, but our rules say 97 must always occur before 13.
In the second part, we’re asked to take all of the ones which are invalid, and then put them in the right order according to our rules.
Naively, I started doing something like the following, take the rules as literal Prolog facts:
before(74, 53).
before(97, 13).
before(97, 61).
Then checking the validity involves some sort of search. This encoding is incomplete though, since if we query before(X, Y) we only get solutions for if X and Y are directly adjacent.
We’re missing the fact that $a$ coming before $b$ is valid; the thin edge in the graphic above.
We can add another predicate:
before(X, Y) :-
before(X, A),
before(A, Y).
This captures the idea that X appears before Y if we have some A which X is before, and that A itself is before Y (either as a direct match to one of the earlier facts, or as a recursive call to this rule.
Then we can validate an ordering by taking pairwise entries, and checking it’s correct by querying before/2.
This should work, but is still a bit too unidirectional. I’m not quite a good enough Prolog programmer to take this further (in the given day’s time to solve the challenge), so I switched gears to Elixir. As is usually the case, if we can find a better representation of our data, the mechanics of the solution should hopefully just fall out.
We can rephrase the problem to be a bit more formal. Let’s define:
Now here’s the graph bit, we can read $R$ to be a set of edges on a directed graph $G$, where $(a, b)$ indicates $a$ appearing before $b$. The graph $G$ now encodes quite some detail:
The last part is the cool part - $(a, b)$ is valid if $b$ is reachable from $a$, that is you can walk a path from a going through arbitrarily many nodes along the way, and end up at $b$ (what our rule before/2) encoded earlier.
Using LibGraph for Elixir (and having turned the input into a graph as the “parse” step made the solution to part A stupidly succinct:
Enum.filter(updates, &Graph.is_subgraph?(&1, ordering))
The ordering being a subgraph of the updates is expressing that all of the nodes in ordering have to appear in the same order as defined by updates, as explained above.
Another way to conceptualise graph H being a subgraph of graph G, is if we can remove intermediate nodes from G to eventually arrive at H:
The second part asks us to fix the out-of-order orderings, per the rules. This again ends up being really simple when modelled as graphs:
updates
|> Enum.reject(&Graph.is_subgraph?(&1, ordering))
|> Enum.map(fn g ->
g
|> Graph.vertices()
|> then(&Graph.subgraph(ordering, &1))
|> Graph.topsort()
end)
We first filter out the ones that are correct, then perform a topological sort on the vertices of the updates which appear in the ordering. A topological sort is what it sounds like, rather than sorting e.g. by some comparator, we sort them by the order in which they show up in the graph. Essentially, walk it from the start to the end, listing out the edges as you see them.
And that’s about it! I’ve probably not explained this too well, but I thought it was really neat. The full code for the solution is on my GitHub repo which contains partial solutions for the rest of 2024. Onward to more graphs.
]]>I stumbled across https://cameronsworld.net the other day. Go and visit it and come back here first.
It’s a fantastic full on, in-your-face torrent of nostalgia for the early web. The kind of web you’d surf. People had little gardens of web sites they’d tend to.
Choose Joy!
My first exposure to programming proper was my first ever ‘homepage’, after we got PHP set up on the OS X Leopard webserver.
I spend hours, days, weeks fiddling with absolute positioned divs, the magic of my navbar.inc.php propagating automatically across all of my pages.
…and that led me to
postcircumfix operators:sub postcircumfix:<⸨ ⸩>( Positional $a, Whatever ) {
say $a[0], '…', $a[*-1]
}
[1,2,3,4]⸨*⸩; # OUTPUT: «1…4»
constant term:<♥> = "♥"; # We don't want to quote "love", do we?
sub circumfix:<α ω>( $a ) {
say „$a is the beginning and the end.“
};
α♥ω; # OUTPUT: «♥ is the beginning and the end.»
Seriously, wtf
So, the ginormous tech platforms do control basically all the ‘the internet’.
And the platforms are run by billionaires, who are most interested in high arousal emotions and people being mad at each other and all that stuff, driving engagement etc.
But the thing about the internet is that it’s not finite, or zero sum, you can just make more of it.
Just buy a domain, stick a few pages up on a webserver and you’ve got your little slice of gif-and-banner peace. Just like, go somewhere else instead of the big platforms. Email your friend.
Write a blog no one will read!
]]>