Platforms

I'm currently thinking about what a reasonable platform for prototyping would look like. To start with:

• Language: Lisp (specifically, ISLisp)
• OS: UNIX. I chose to not support other OSs like Windows back in the OpenCOMAL days, and it's interesting that the EISL maintainer decided the same.
• Libraries: UNIX again. Modern UNIX actually has a moderately rich feature set. It's not as minimal as you would think. I think a lot of the time when people want a Lisp library, a standard UNIX library wrapped would do fine (and the wrapping is easy). The rest of the post is about this.

EISL compiler internals, including details of the FFI

UNIX Libraries

Again going back to the OpenCOMAL days, here are some of the features I tried to use:

• Text user interface using curses. Following my longer proposal, I think a GUI is overkill at this stage.
• Localisation using catopen/catgets/catclose

OpenCOMAL interpreter

Proposal for hardening prototypes

And some I would have liked to get around to:

• Interoperable serialisation using xdr
• Somewhat-transparent persistence using ndbm

Notably, all of the above are considered boring enough to have been standardised by orgs like X-Open or the IETF. This is not intended as a criticism, quite the opposite.

The eventual aim is that I would like something like multi-user interpreters, e.g. a MUD (I liked ColdC/ColdCore) but using COMAL as the language. I might have preferred to start from the existing OpenCOMAL, but unfortunately after reading a paper on AFL a while ago I wouldn't connect any software written in a non memory-safe language to the Internet.

I probably won't ever get that far, but taking the advice of (I think) the comp.lang.lisp FAQ, if I write some useful libraries along the way that's fine. Repl.it seem to be in this space but they actually have some funding :-)

Other Libraries

Reading back on this, it resembles an old post I wrote on learnings from some embedded systems projects. There I concentrated on

• Debug logging (I would add some kind of design-by-contract/assertions to this nowadays, GNU Nana worked well for OpenCOMAL)
• Finite State Machines (although this was more of a reusable design pattern than reusable code)
• Unit testing framework

On PC-class hardware debug logging is probably better done by syslog. The others two are still nice to have though, although

(Oberon) Programming in the Large

GNU Nana

Back to my gemlog