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

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.

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.

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.

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.

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.