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 to 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.

Flashcards and Anki

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 university 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

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!

Reviving Old Software

As an aside, I’ve been really impressed by some recent really cool software/tech conservation, people 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 :)

Source Code

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 acquires 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.

Building for macOS

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);

GeniusAssociationEnumerator.m

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.

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:

• The set of page ids I, which in our case is just integers, but these can be arbitrary labels.
• The set of rules R, which are pairs of page IDs (a, b), indicating that a must appear before b.
• The set of orderings O, which is a proposed ordering of page IDs.

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:

• What page IDs are covered
• What page IDs are directly adjacent
• What page IDs may appear before another

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.