Faré Rideau

Got one of these myself (in a IIci with a Daystar accelerator and an 8-24-GC video card, 8MW of memory, standard Genera patched for Y2K). It was quite expensive to source and to rehabilitate. Lisp machines are a bit hard to get used to, and I definitely don't claim to be a Lisp deity, but their interfaces demonstrate a great deal of thought and orthogonality that's profoundly missing from a lot of modern UI. Under the hood the MacIvory implements a Front-End Processor to mimic their workstations. It's a multistage boot: boot the Mac, start the FEP ("Breath of Life"), start Genera. Oddly, while the FEP on real Symbolics boxes is a 68K, the MacIvory CPU handles it directly, sort of like a bootloader. There's a nice memory dump here: http://fare.tunes.org/LispM.html

Listen to "Philosophy: Who Needs It?" [1] (duration 40 minutes; and/or read it [2]) -- an address by Ayn Rand to the 1974 graduating class at West Point. Whether you agree with her philosophical theory or not, she makes a brilliant case for the layman needing philosophy (for life on earth). [1] http://aynrandlexicon.com/ayn-rand-works/pwni.html [2] http://fare.tunes.org/liberty/library/pwni.html

The "PCLSRing" technique to essentially back out of an active syscall is worth studying: https://en.wikipedia.org/wiki/PCLSRing http://fare.tunes.org/tmp/emergent/pclsr.htm. It's much better than the UNIX approach of returning early with an error or incomplete data.

A capabilities system in Scheme was done in the 90s, though AFAIK it is now dead. Still the paper describing it is worth reading and may give you some inspiration: http://fare.tunes.org/tmp/emergent/secureos.htm

Much of the memory in a Lisp program is in the form of CONS cells, so the MIT LISP machines had a compact way of encoding this. They also used tagged memory to be able to handle the different kinds of data at runtime. They inherited a very stack-oriented execution model from the PDP-10 implementation of LISP. And they implemented very complex instructions using microcode. The Symbolics people refined this approach while the LMI people kept the original design until nearly the end when they tried to do a RISC+tags: http://fare.tunes.org/tmp/emergent/kmachine.htm

The K-Machine would be a super interesting retro-computing project to get going. The schematics, the Lisp Machine system associated for it, are available (I'm unsure of legal status). If anyone is interested in driving that, I'd be really interested to help (but my primary interest is just the CADR due to lack of hours in the day :-) ) Here is a wonderful article about the K-Machine: http://fare.tunes.org/tmp/emergent/kmachine.htm

On the topic of ITS, there's a pretty interesting paper on its PCLSRing feature, PCLSRing: Keeping Process State Modular by Alan Bawden [1] I've read this a few times over the years, and always find it a fascinating alternative approach to handling interrupts. [1] http://fare.tunes.org/tmp/emergent/pclsr.htm

For the curious, there is more information on the K-machine here: http://fare.tunes.org/tmp/emergent/kmachine.htm

cf.;Philosophy: Who Needs It. By Ayn Rand. http://fare.tunes.org/liberty/library/pwni.html tldr: Everyone needs a rational philosophy.

The last CPU that was being developed at Symbolics is actually RISC: https://en.wikipedia.org/wiki/Symbolics#Sunstone The competitor LMI was also developing their next-generation Lisp machine RISC processor: https://en.wikipedia.org/wiki/Lisp_Machines#GigaMos_Systems More about the latter: http://fare.tunes.org/tmp/emergent/kmachine.htm

I posted these links elsewhere in the thread, but I think they'll be of special interest to HN readers, who might want to know about the more technical aspects of her philosophy. An index of her thoughts on many topics: http://aynrandlexicon.com/book/conceptual.html A graduation speech which summarises her views on philosophy in general: http://fare.tunes.org/liberty/library/pwni.html Her most technical work, her theory of concept-formation (and the book that sold me on her ideas): https://www.amazon.com/Introduction-Objectivist-Epistemology-Expanded-…

That they ended up emulating Genera instead of porting it should tell you something. Maybe. Also, look at the trouble people go through to do that: http://fare.tunes.org/LispM.html Then there's this that makes it look easy but also shows the keyboard problem LispM was probably referring to: http://www.loomcom.com/genera/genera-install.html What I find on getting them running without LISP hardware is somewhere between tough and "wow, I feel for that person." Maybe things have improved. There just seems to be a huge mismatch between many aspects of LISP machines and modern machines that means it's probably easier to do a clean-slate LISP machine that builds on modern primitives & interfaces better.

All system calls in ITS behaved as if they were atomic, using a mechanism called PCLSRing: http://fare.tunes.org/tmp/emergent/pclsr.htm Other systems which took a similar approach were WAITS, the Fluke Kernel, and EROS and its successors.

[0a] http://fare.tunes.org/LispM.html [0b] http://www.loper-os.org/?p=405

Also in the LMI K-machine [1]. I got part way through building type checking hardware to use with Franz Lisp on 68k CPUs. Franz Lisp allocated objects of a single type in each page and the 68k had function code pins that meant you could tell whether a bus read was for data or instruction fetch, the idea was that I would modify the compiler to read a latched type value just after a Lisp object had been read into a register. [1] http://fare.tunes.org/tmp/emergent/kmachine.htm

As someone who has never used a Lisp machine, it interests me to hear about the complexities of the machine. I have been considering buying one, perhaps through the same detailed here: http://fare.tunes.org/LispM.html. I don't think I'd use it for any active development, but it would be a fun hobby tool to hack around on. Anybody here besides Paul have much experience on a Symbolics LM?

> Lisp machines were thoroughly in the "mini"computer (cabinet-sized) category and completely missed out on the microcomputer revolution. Symbolics and TI both developed microprocessors for Lisp in the 80s. TI promoted their Lisp chip as the 'Megachip' enabling the 'Compact Lisp Machine'. It was the first microprocessor which integrated around a million transistor functions. Both put the Lisp Machine for example on small Apple Nubus cards and inside an Mac II. The TI MicroExplorer and the Symbolics MacIvory were popular Lisp Machines. This is a MacIvory board which contains a Lisp processor, a Weitek numerics chip and memory: http://fare.tunes.org/files/pics/lispm/2003-01-19-lispm-macivory3-knee… A Mac II with a Lisp Machine inside: https://i.imgur.com/b3XkHpS.jpg This is a picture of two Symbolics NXP 1000 Lisp machines, which also use Lisp chip: http://lispm.de/symbolics-nxp1000-inside/thumbnails/IMG_3044.jpg Basically the size of a typical pizza box machine at that time.

Ruby is far from an 'acceptable' lisp. The article's first premise of what are lisp's virtues is dead wrong. First Lisp is NOT a functional language. A functional language is one that maintains referential transparency. i.e. where I can replace the reference/variable with its value its semantics are unchanged. Common Lisp is a multi-paradigm language and pervasively uses the the concept of places to setf state. And in a more general lisp sense, macros are opaque to the run-time and directly opposes referential transparency. His second statement, Ruby gives you 80% of what you need of macros, implies that we know what macros are for. Macros are not a solved problem, you can see Racket is actively researching macros. For example, how does one do meaningful error reporting in macros? And given that macros, generally, are programming at compile time the statement is as analogous to saying we know what we are programming for, a statement I couldn't disagree more with. The quid of Lisp I would argue is not specifically macros, but its 'meta-circular semantics', that is to say, the capacity of lisp to speak of itself in a meaningful way[0][1]. For example, in C++ we can speak of C++ but not in C++ but in its template language, that is to say a meta language. Lisp is its own meta language. We could also speak of Python in Python, for example express Python's for loop in python[2], except there is now way to replace python's definition of for with my own. BTW, that doesn't mean…