Posts on Azrea Amis

Compiling Forsp Stacklessly

Mon, 21 Apr 2025 10:45:30 +0200

Forsp is fascinating language billed as a combination of Lisp and Forth. It’s stack based, but features easy idiomatic access to a local environment. This gives you the simplicity of Forth, but offers an “escape hatch” out of stack hell. Code that would require complicated stack/value shuffling in Forth can instead name the values and manipulate them in a way more natural to Lisp programmers. Forsp is also neither call by value nor call by name, but instead call by push value, though I’m not entirely clear on why this is interesting as I haven’t read the paper yet.

How I reduced my Gitlab CI Runtime by 80%! (Clickbait!)

Sat, 13 Aug 2022 13:52:29 +0200

I use Gitlab to host a lot of my repos and I have one particular repo that runs CI a lot. It’s more convenient when it runs fast and it’s a lot cheaper on build minutes. It used to take nearly 4 minutes to run. Now it takes just 40 seconds. Why did it take so long in the first place, and how did I make it so much faster?

Weak Heterosexuality

Sun, 20 Feb 2022 10:36:42 +0100

Heterosexuality and homosexuality have commonly understood definitions in western society. For reasons that will become clear, let’s refer to this as Strong Heterosexuality and Strong Homosexuality. For historical reasons, Strong Heterosexuality refers to a relationship consisting of exactly one man and one woman. Some proponents of Strong Heterosexuality include other descriptors like requiring it to be “for the purposes of procreation”, but this is out of scope as this article only considers the classification of relationships.

Org Setup

Wed, 15 Sep 2021 17:40:00 +0200

Emacs and Org posts are a dime a dozen on the internet, and they’re usually extremely specific, going into precise detail on how the author uses every tool in Org’s arsenal. I usually find these blog posts overwhelming and not particularly useful. Maybe I’ll pick up some tricks and integrate them into my own setup, but usually my eyes glaze over and I leave none the wiser. So rather than explain my system in detail, I’ll just list some basic tricks you might find useful for your own setup.

Nomad on ARM64: Cannot Join Network

Mon, 20 Jul 2020 16:03:35 +0200

I recently got a Raspberry Pi 4 model B, and I wanted to do the usual “deploy container orchestrator” thing, but I didn’t really want to do a full Kubernetes cluster because that seemed like overkill for such a small computer. I’d lose a lot of capacity to Kubernetes services even if I used a small distro like k3s. For the lower overhead and easier setup, I decided to go with Hashicorp Nomad instead, targeting a single node cluster with for now.

"Interesting" Clojure Macro Interaction

Sun, 15 Dec 2019 23:01:08 +0100

Clojure’s macro system is a little tricky to work with (at least for me), but it’s also quite powerful. Being able to rewrite the languages AST at compile time is really cool, and the fact that Clojure’s syntax is just the data structures that normal Clojure code operate on makes writing macros a breeze (at least compared to, say, Rust or Javascript). Clojure’s macro expansion works in dependable way: it keeps apply macros until there are no more macro calls in the code, then compiles the resulting code.

Monorepo Compromise

Sun, 03 Nov 2019 20:54:26 +0100

I have a modest proposal on repository organization. There are 2 primary archetypes, multiple repositories and the monorepo pattern. In multiple repositories, you have 1 project per repository, binaries requiring internal libraries, and use tools to ensure that you have all the necessary repositories downloaded and up to date (easy with most modern package managers). In a monorepo, all projects are stored directly in the monorepo, as part of a single codebase or project, and all internal dependencies are automatically managed.

Ironic Space Lisp Part 9

Thu, 29 Aug 2019 14:05:09 -0700

It’s been a long time since I last worked on ISL, mostly because I got distracted by other projects and languages: things like the flows project, or Clojure. Also, writing futures code in Rust is painful. Recently, async-await syntax got released on Rust nightly, which makes async code much easier to write. When I was last working on the project, I was working on a local variables feature. VM operations to allow storing and loading local variables linked to the frame stack, and later, support in the compiler.

Clojure's Looping Syntax is Surprising

Thu, 30 May 2019 11:52:59 -0700

They aren’t super popular, but Clojure has a rich set of high level looping macros. You have for for list comprehensions, doseq for imperative looping over sequences, dotimes for an even simpler integer loop, while for raw predicate looping, and loop for any kind of arbitrary recursion-style looping you want to do. However, I’m not a huge fan of the exact syntax some of these macros use. Let’s talk about let, which looks like this:

Codegen Loader

Tue, 28 May 2019 17:04:04 -0700

In what is very likely an enormously bad idea, I have built a JVM classloader that can load dynamically load Java source files into memory. Why I’ve recently been going “Full Juxt”, using all of Juxt’s Clojure libraries, specifically juxt/aero for configuration, juxt/bidi for routing, juxt/yada for endpoint handling, weavejester/integrant for “building applications” (probably dependency injection), juxt/joplin for database migrations, and juxt/edge to tie it all together. All of Juxt’s libraries are relentlessly data focused, and use deps.

Netns socat Trick

Thu, 16 May 2019 11:57:15 -0700

I mostly use this blog for theories, ideas, and think-pieces. But I figure I’ll return to the roots of blogging, and take the opportunity to explain a solution to a technical problem I encountered. The Problem I have a home lab server I built out old gaming PC. I haven’t done anything with its mediocre graphics card (so no exciting machine learning stuff). I’ve used it as a file server and a render box (blender’s CPU rendering only), but I’ve also used it as a VPN client.

Game Idea: "Annihilation: God's Will"

Thu, 09 May 2019 13:14:25 -0700

God created this world. Now, he’s finished with it. I’m not entirely sure what medium best fits this story, but the idea started live as a story driven cRPG, so I’ll explain it like that first. Story The story begins in the holy city of Kalstar, rumored to the oldest city in the world, and home to the God’s Grand Temple. In the final chapter of God’s bible, He states that the world will end precisely 1000 years after it started.

Intentional Limit Breaks in Video Games

Mon, 14 Jan 2019 11:58:20 -0800

When building consumer software, it’s a widely held belief that the software shouldn’t crash, shouldn’t hang (or ignore user input), and should generally remain “in control.” Users don’t like software that crashes and loses their progress, and they don’t react well to software that freezes: they tend to spam buttons, making the problem worse. This is just as important and much harder for video games. Video games are among the most complex and demanding software being produced commercially, and they’re likely the most complex and demanding software the average consumer will ever run.

The Triumvirate of Aberrations

Fri, 14 Dec 2018 13:35:11 -0800

While attending college, for a variety of reasons too tedious to go into, I frequently dined at my college’s dining hall. I dined there on and off for all 4 years, and got to know its quirks: most usefully, what they could cook, and what they couldn’t but still attempted. However, I also learned some of the lore of the place, like the tale of The Triumvirate of Aberrations. I know these artifacts exist, for I have witnessed them personally.

Pipeline Operators

Sat, 03 Nov 2018 19:28:01 -0700

Pipeline “operators” or “threading”1 constructs are interesting language constructs. They are an acknowledgement that functional code can be a little obtuse. They reorient (or rewrite) functional code so it looks more like a “dataflow”. Particularly of Lisps, but also of some other functional languages, execution moves from the inside of expressions to the outside in a way that’s not particularly natural feeling. It’s a real source of the difficulty people express when reading functional code.

Flows the Wrong Way, Part 2: The Right Way

Sat, 13 Oct 2018 12:36:21 -0700

Note in 2022: I’m in a very different state of mind compared to when I wrote this, and neither part represents my modern voice or style particularly well. I think it’s still a good story.

In my last post, I covered my first attempt to implement TCP streaming in Flow, a data flow library for Elixir. My first attempts involved a bunch of failed Unix sockets, and an attempt to implement a GenStage that failed for reasons I didn’t understand. I eventually settled on this:

Flows the Wrong Way: Streaming into Elixir

Wed, 10 Oct 2018 15:41:01 -0700

Note in 2022: I’m in a very different state of mind compared to when I wrote this, and neither part represents my modern voice or style particularly well. I think it’s still a good story. As part of a new and exciting project, I was faced with the task of ingesting a large amount of more or less homogeneous JSON data into a SQL database for an associate of mine to do some rudimentary business intelligence analysis on it.

Ironic Space Lisp Part 8

Thu, 20 Sep 2018 13:21:53 -0700

It’s been a while since I posted progress on ISL, and that is mostly my fault. Most of this time was spent making maintenance, like documentation, but also trying to get the self hosted interpreter working and self hosting. That was a challenge, and also my fault.

The Phantom Rejection

Fri, 14 Sep 2018 17:10:34 -0700

I’m unemployed, so I’m constantly applying to jobs, and have posted my resume to a couple of job boards, attempting to prompt semi-cold calls from recruiters. And it’s worked, to an extent. I haven’t got a job, but I’ve gotten a couple emails from recruiters. I also got a rejection email. Not unusual, some companies decide to let me know that I’m no longer being considered for a position. But I never applied to this company.

Ironic Space Lisp Part 7

Mon, 27 Aug 2018 15:56:11 -0700

Let’s talk about the VM internals. I’ve written a compiler for ISL, and implemented functions at the same time. This is not a mistake or an over-reach, rather a natural progression. To the VM, what is a function? The VM doesn’t have a strong concept of “functions”, or even of procedures. It has the Call and Return operations. These operations are the only way to manipulate the frame stack in a meaningful way: Call pushes an address to the frame stack, jumping to it, while Return pops an address, returning to the caller.

Ironic Space Lisp Part 6

Wed, 22 Aug 2018 01:56:10 -0700

Since last time, I did two things: switched from error_chain to failure, and refactored with the visitor pattern. They took about the same amount of time, and the refactor is much more interesting. I briefly touch on an issue I encountered with failure, but I’d rather discuss the refactor.

Ironic Space Lisp Part 5

Sun, 19 Aug 2018 20:44:24 -0700

Let’s talk about environmental bindings. I’m taking the unusual (I think) approach of sharing environment bindings code between the VM and the interpreter. Unfortunately, I wrote the environment code at the same time as the VM, and fit the code a little too closely to the requirements of the VM, and didn’t think enough about what the interpreter would require. In the process of writing the interpreter, I encountered a strong disconnect between the semantics that I wanted and the semantics I had.

Operators

Wed, 15 Aug 2018 16:21:39 -0700

I recently started thinking about operators and math in programming languages. This is at least partly inspired by the programming language I’m making right now, but I’ll get to that later. It’s also inspired, in some sense, by the tutorials I was reading while trying to successfully parse my programming language. I didn’t find a tutorial specifically for what I was trying to do, which was fair, but I did find tutorials on parsing other more “normal” languages or more C-like languages, and it got me thinking.

Ironic Space Lisp Part 4

Sun, 12 Aug 2018 00:41:11 -0700

This update is all about parsing, and this ended up being really difficult. Not in a good way though. In my last post, I talked about using languages so difficult and alien that the difficulty clearly signified that there was something important you could learn from mastering them. I didn’t find this was the case during this phase of the project.

Ironic Space Lisp Part 3

Fri, 10 Aug 2018 17:09:28 -0700

Have you ever been working on a project and felt stupid and scared? Not in an anxious way, and not in an imposter syndrome way, but in a visceral way, like “I don’t really know what I’m doing, and I’m not sure I can do this.” Some languages are so complex and different that, although I know they’re full feature and Turing complete languages, I don’t know that I can even write whatever program I’m trying to make.

I hate Go, and I think it's really cool

Wed, 01 Aug 2018 14:02:48 -0700

My first impression of Go was, ironically, “kinda generic”. It’s an imperative language from Google inspired by Python (a little generic) and Java (reigning king of generic languages,) so some amount of “recognition” is due. Go wears its influences proudly on its sleeve, which is a little weird, because it’s not a particularly noteworthy heritage. The interesting thing (to me at least), is that this is all on purpose. Boring on purpose is an engineering feature, because excessively complicated languages are harder to work on, and produce harder to maintain code.

A Hybrid Course

Sun, 29 Jul 2018 20:05:19 -0700

I took a lot of interesting courses in college, but I wanted to talk about a particular course that you might call a “hybrid course”. This particular course was outside my major: I was required to take non-CS courses to get my degree, but by senior year, I had also run out of CS courses to take; what is a man to do? Take a course on Ovid and Medieval Literature.

Ironic Space Lisp Part 2

Sun, 29 Jul 2018 10:59:40 -0700

Part 1

Part 2

Last time, the conceptual challenges of a the stack VM convinced me it was the wrong approach. In a normal recursive lisp interpreter, code is data, and you have a single evaluator function over every value. Follow along here.

Ironic Space Lisp Part 1

Sun, 29 Jul 2018 02:03:01 -0700

Part 1

Part 2

I recently had a new idea for a space programming game. The idea isn’t done, although the planning document is getting lengthy. Programming games need programming languages, and based on the game design, I had some pretty particular specifications for the language.

Game Idea: Compressed Dungeons, pt. 1

Fri, 04 May 2018 09:29:00 +0000

tldr: moba keystone dungeons Traditional cRPGs are, in general, united by a strong emphasis on character progression. By playing the game, and completing challenges, your character gains experience, sometimes represented by literal experience points, and becomes stronger, more capable, and better equipped for even more challenging encounters. This is frequently associated with numerical increases (allowing you to crush old content with pure numerical advantage), and in many cases, although you grow stronger your enemies do to at a carefully controlled rate that matches yours, and in some cases comparatively exceeds yours, making later enemies harder and harder to kill so the gameplay still has a positive difficulty curve.

Hacking Turntable for Fun and Music

Fri, 25 Nov 2011 15:12:00 +0000

Previous Solutions Turntable is a collaborative DJ website that lets people play music to an online audience. Turntable, by default, doesn’t let you download the music you hear. If you hover over the track name in the UI, you can scrobble the track to Last.fm, find it in Spotify or Rdio, etc. Some people (myself included, but we’ll get to that later) wanted to download the files being played. So, a Greasemonkey script was created to automatically download songs as they were played on Turntable.