2023.06.02
As long as I can remember I have loved the process of defining, designing, and implementing my own programming languages. I’ve created so many languages that you could say that I’ve created something of a programming languages zoo. Below you’ll find a list of the languages that I’ve created over the years and those that I’m thinking about currently.
| Project | Status | Synopsis | Impl langs | Next Goals |
|---|---|---|---|---|
| Clojure | maintainer | The Clojure programming language | Java + Clojure | [ ] keep rockin’ |
| Cribbaj | delimiting | An implementation of Forth with IDE and VM | C + Ruby + Cribbaj | [ ] kernel-forth definition |
| Folog | prototyped | An Prolog implementation | Common Lisp | [ ] port to CLJ |
| Quincunx | prototyped | A small functional language with FEXPRs | Clojure -> C | [ ] read and annotate Shutt |
| Incal | documenting | Minimal implementation of the J language | C | [ ] org-mode babel |
| Ix | dev | An OO language with production rules | C + Ix | [ ] test harness [ ] vectors |
| Juxt | prototyped | A functional concatenative language | Java + Juxt | [ ] reader impl |
| Lithp | released | An implementation of McCarthy’s original LISP w/ macros | Python + Lithp | [ ] perpetual hacking |
| Minderbinder | prototyped | An RPN command line calculator with units of measure | Python / Clojure | [ ] define uom specs |
| µPy | dev | A very small implementation of Python | C + Python | [ ] decorators |
I’ve been a full-time member of the Clojure core team for two-years and have worked to maintain, fix, and enhance the language and ecosystem. I certainly would not say that Clojure is “my” language, not even a little bit, but I have contributed enough to warrant mention. Perhaps one day when the Clojure history book is written I will get a paragraph.
Cribbaj is a Forth implementation that’s intended to start with the Forth-83 spec and expand into a more modern and portable implementation. The ideas that I would like to explore with Cribbaj are meta-compilation, meta-programming, kernel-Forths, IDE design, and batteries-included language implementation. The historical precedents for Cribbaj include: KAMAS, Forth-83, MMSForth, FIG Forth, and colorForth.
Some references that I’m using for design include:
Some thoughts and ideas about the direction that I’ll take Cribbaj is found in my thunks repo.
Folog started as a fork of Hideyuki Nakashima’s PPiCL – an elegant and mind-warping little interpreter. I added extensions such that I could in turn implement a little LISP in the language but I have not taken it further. Eventually I would like to port the original logic to Clojure and occasionally hack on it toward that goal.
Quincunx is currently implemented as a mini interpreter written in Clojure. The purpose was to better understand FEXPRs, and while I think that goal was achieved, it would be nice to take it further. The natural path is toward the Kernel language, but some study needs to happen on my part before I can proceed. I would like to create a small interpreter in C and explore simple GCs, but that is further in the future.
Some references that I’m using for design include:
This started as the original C implementation, J Incunabulum but I took the effort to translate the code into a style that fits my own style. Many similar efforts have since happened over the years but this one is mine. I would like to eventually make a literate version of this.
Ix is a language that I’ve been hacking on for 20 years. The seed of Ix is found in CLIPS, especially in the COOL subsystem. The central conceit of Ix is this: can we mitigate the complexity of object-oriented programming by describing and scoping instance mutation in-terms of production rules?
Some references that I’m using for design include:
Ix has been rewritten no less than three times and has gone from a Smalltalk-like system to a Lisp-like system to something in-between. I will probably hack on this until I die… in fact, it might kill me.
Juxt is very much inspired by Joy but I would like to incorporate some of the ideas in Clojure. A prototype was written in a weekend and allows code such as below:
/swoncat (A B : B A)! cat/
/Y ($cons) swoncat $cons i/The code above implements the Y combinator and if you know Joy then
you’ll understand that the functions cat and
$cons are list manipulation operators. Indeed, Juxt (like
Joy) uses quotations as its lambda representation, which are simply
lists that may or may not have some context attached to them. If I were
to describe Juxt in one sentence it would be: a homoiconic, functional,
stack-based, concatenative programming language with: lexical scope,
closures, tail-recursion, a stack-effects mini-language, first-class
environments, destructuring, modules, metaprogramming support, dynamic
type checking, and Java interoperability. The simplicity of the language
is such that the kernel was written in a weekend and further features
like modules, recursion, lexical binding, and shuffle operators were
written over time in Juxt.
Some references that I’m using for design include:
Lithp is an implementation of an interpreter for the original LISP as described by John McCarthy and the macro system described later by Timothy Hart. The interpreter implements the following seven functions:
atomcarcdrcondconseqquoteand also two special forms:
labellambdaUsing these functions I also implemented a Lithp interpreter in Lithp
itself that implements the same 9 features and also added a
macro special form.
Minderbinder started as a Clojure library of the same name providing unit of measure conversions. However, over time it took on a life of its own and has since morphed into a command line RPN calculator supporting bignums and unit of measure awareness. It’s not a general solution yet and needs some work to be usable by someone other than myself.
Some references that I’m using for design include:
µPy is a spike of tinypy by Phil Hassey that I at one time considered for the front end to Ix (mentioned above). However, I never went that far and instead left in some of the features that Ix and later Python had, including:
I don’t know how far I will go with this.
Some references that I’m using for design include:
| Project | Status | Synopsis | Implementation | Eventual Goals |
|---|---|---|---|---|
| 370 ASM | lost | An assembler for a subset of IBM 370 assembly | C | [ ] invent time machine |
| Baysick | released | A embedded BASIC DSL | Scala | [ ] make work in Scala.latest |
| Eleusis | prototyped | An implementation of microKanren | Clojure | [ ] speed up unification |
| Mouse | lost | An implementation of the Mouse programming language | C64 BASIC | [ ] invent time machine |
| Pascal | lost | A compiler for a subset of Pascal that targets a simple VM | C | [ ] invent time machine |
| Russ-Forth | released | A teeny-tiny Forth-esque | Ruby | [ ] stdlib |
| Tori-Lisp | released | Small functional programming language | JavaScript + Tori-Lisp | [ ] in-broswer IDE |
| μLithp | released | A micro LISP implementation in 24 lines | Ruby | [ ] interop |
This was an IBM System/370 assembler that I wrote in college. It has been lost to the dustbin of history.
Baysick is a Scala DSL that allows embedded BASIC-like syntax. It worked on a version of Scala circa 2009 but has not been maintained since.
Like everyone in the Clojure community, I also created an embedded microKanren library. Eleusis was slightly different in that I also implemented a REPL that read microKaren forms and executed them.
Some references that I’m using for design include:
Possibly my first language was a janky implementation of the Mouse programming Language on my old Commodore 64. I doubt that I implemented the whole language but the parts that I did were simple because the language can be implemented by simply walking an array of bytes and calling dispatch subroutines for each byte. In all likelihood I only implemented the mathematical operators and possibly variables.
Also in college I implemented a 1-pass Pascal compiler that targeted an intermediate quadruple language and a little interpreter for that IL.
I implemented Russ-Forth years ago after being nerd-sniped by my old-friend Russ Olsen.
Tori-Lisp is a code riff that I created from from Mary Rose Cook’s lovely Little Lisp. The central conceit was: what would you need in a Lisp that didn’t have macros but felt like it did?
μLithp was an experiment to see if I could create a Lisp-like interpreter in less than 30 lines of Ruby. It took 24.
There are certainly more than those listed above, but any additional exist only on dusty archives and not in my brain case. I can only hope that they bubble to the surface one day.
:F