awarm.spacenewsletter | fast | slow


This edition of A Warm Newsletter revolves around loops. Specifically, three different loops: a video game loop, a learning loop, and a software development loop.

Hades and rouge-lites

The first of these loops is the most potent. I bought Hades this week and I have played an embarassing amount of it already. It's a shining example of a cursed, loopy, genre: rogue-lites.

While all games have loops, these games are loops. They're characterized by:

  1. Randomly generated branching levels
  2. Perma-death runs (i.e if you die you start back over at the begninning)
  3. A huge library of power-ups, randomly drawn from for each run

These games are a weakness of mine. It started with Spelunky in my youth and the curse has stayed with me constantly. They're hard and unforgiving, and incredibly addictive.

Each run you make is unique, and feels just a little like a slot machine. But it's not just a random reward schedule. The challenges the game presents is perfectly consistent and fair, so each time you die you know you could've survived, and many times you know exactly how.

These two traits, novelty and awareness of what to do next to improve, are very desirable traits for any kind of learning environment.

Rogue-lites perfect it by shaping their core task almost solely for those two traits. They cheat a little by giving you power ups, so even when your skill isn't improving, you still make progress.

It's much harder to achieve this if you want the core task to be something generalizable and useful, and not just getting really good at a specific video game.

Anyways, in the realm of video games, Hades is an absolute gem of the genre. It's not quite fully done yet, but it's already extremely polished. And, unlike any other game I can think of, it manages to make narrative an integral part of the game loop.

Like I said, it's potent.

Execute Program and Spaced Repetition

The second loop is much more explicitly educational, and a lot less "just one more run".

I've been doing two courses, on SQL and regexes, on Execute Program. Initially they behave like other online programming tools I've encountered, you progress through a linear text, interspersed with excersises. When you finish a lesson though, Execute Program sets itself apart. It stops you and tells you you have to come back tomorrow.

When you come back, you'll be met with a quick review of the exersises you did, and then once you finish them, then you can get start more lessons.

This paced experience feels a lot like progress in Hades. As you invest more time, more abilities (lessons) become available to you. As you encounter them more often, they get cemented in your mind.

This general structure is spaced repetition learning.

The spaced element comes into play when you review exersises, if you get them right the system will increase the time till you have to review it again.

What's extremely neat about it, is how it maps to memory. As you encounter the exersises more, you have to review them less.

These kinda of systems are an incredibly exciting frontier for learning tools. More than just memory, they're a way to encode arbitrary tasks into a loop, such that you always know what to do next, without ever having to explicitly specify exactly when you want to loop back to something

Fancynote and TDD

The last loop is the most boring. It's a software development technique I've starting using on Fancynote, complete with a swanky acronym: TDD, test-driven development.

There's a lot written about the subject, and I'm definitely less of an expert than I am on rogue-lites, so here's a summary:

  1. Figure out what properties you want Program A to have
  2. Write a seperate Program B that uses Program A and tests that those properties hold true.
  3. Write Program A until Program B tells you it has all the properties you wanted
  4. Go back to step 1

If you split Program B up into small parts for each of the properties you want to implement in Program A you end up with an executable checklist that tells you what you need to do to make your code work.

Tools for test drive developmemt are really good. I've been using jest. It:

What this amounts to is a very lovely development loop. You slowly right code and get more green check marks as more things work!

The exersises in Execute Program are basically a test suite as well. You answer all of them in code, and they tell you if it matches the expected behavior or not. I wonder if software like jest could be extended to handle a spaced repetition system...

Looping everything together

While the three examples here progressed from entertaining to more practical, each also increased in freedom.

In a game like Hades there's really an incredibly limited amount of things you can do, (maybe something like 6 buttons + joystick total?) And absolutely everything in the environment is training you to press those buttons in the right order to win.

With execute program there's more options because you're writing code, but you're still guided along and validated by the system and curriculum set out by the course creators.

And finally, software tests are entirely your own, you define both the measurement and the inputs.

What I'd like to explore is ways to make systems with the freedom of test drive development, and the power and potency of Execute Program and Hades.