Limiting   cases  are interesting.   My project  with  @amszmidt@mastodon.social
[[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.