Limiting cases are interesting. My project with @
[email protected]
[[tumbleweed.nu]] is to search for the cadr-4 [[
https://github.com/ams/cadr4]].
Particularly, the microcode and corrollary processor written in VHDL, my
description of which will follow.
High level constructions of lisp are built out of low level constructions of
lisp. Not every language has both #'FORMAT and #'LDB, so I think the language is
very ground-up. How we reach ground level is an interesting limit of lisp
implementation.
Now, and historically microcode was used. A non-lisp fundamental language is
hardware described into existence, the language of registers, bits, buses,
clocks. It's not appropriate to imagine this microcode is inside lisp, since
lisp basically protects the programmer from those harsh realities. Once having a
little microcode and microcode processor, the fundamentals of the lisp are
written using the new microcode and the rest will be history.
The existence of the microcode splits development. Lisp and higher level lisp is
blissfully unaware, but the microcoding of fundamental lisp functions can be
redone and redone. Independently, the implementation of the microcode itself can
be improved to some end or other.
We're using VHDL, Very High Speed Integrated Circuit Hardware Description
Language on this quest. This three months of microcode invention is only
required to run in GHDL, which simulates VHDL-described circuits, which may not
actually be synthesisable (realisable with available hardware). There is no
requirement of synthesis for this part of the project.
There are the microcode/simulation ports of the 70s-80s' lm-3 (see Alfred's
site) so there's less far to jump, standing as we are upon our forebears. And
we have various access to their available writing then and since, and
potentially directly in cases like KMP's [[nhplace.com]]. When filling in
details I missed about lisp's nature and history, KMP related the usefulness of
18 bit pointer words on the 35-bit PDP-10 and their relation to being able to
index one moby (million words) and how the language and hardware of computing
grew together and towards each other.
Aside from learning by participating, we also have to realise the implementation
of these microcodes in light of massive RAM and disks, as well as the breadth of
available FPGAs. To an extent that is not the requirement here, we are simply
implementing similar microcode with the ways (words, arithmetic and so forth)
the available FPGAs have been optimised for.
I am poking around the literature on FPGA microcode design, and I'll fossick for
a recent book on the topic since we have the responsibility to not be
historically re-enacting what the lisp community already achieved: Rather we
must make the same kinds of achievement today that were made then.
Here I was going to stop, but escaping the monopoly of consumer computers into
specialised hardware (kind of) with better defined and restricted power and
manufacturing constraints should have positive environmental ramifications in
line with degrowth and abating consumer norms of technological consumption.
