Lisp Machine Puns

I was thinking about this earlier.

Is there a LISP implementation that has a direct one-to-one LISP to machine code API?

But then I thought that would be naive..

So this lead to my question:Why can't there be a LISP dialect/system that directly translates to optimal machine code?

(Forgive me if some of my assumptions are wrong/invalid).

Let's say I obtain the source code for this hypothetical LISP compiler/dialect/system.I then build it on my computer, thus, after being built, this compiler knows the exact limitations/optimizations it can use for my machine.

Afterwhich, I can now write LISP code and evaluate it within my environment. With the resulting code being highly optimized native machine code.

For example, let's say I just want to evaluate within my environment the code snippet:

(defun zero-out (n)
  (setq n 0))

After evaluation my current environment is updated somewhere with the containing code:

zero-out:
  xorl %eax, %eax
  retq

BUT, this is only due to the fact that during the compilation of this hypothetical LISP compiler/dialect/system, that the semantic was defined such that:

(defmacro setq (n m)
  `(if (eq ,m 0)
       (emit "xorl %eax, %eax")))

With the compiler filling in that semantic information during compile-time.

Is this making sense?

What I'm envisioning is a LISP system that outputs compiled and optimized machine code at run-time when evaluated through a REPL or an EMACS environment; due to the fact that many compiler optimizations for the given machine were already figured out at compile time (obviously compiling a complete program using this hypothetical compiler would be able to do even more optimizations due to it having more context (the example I gave was just a simple toy example) as to what the program is trying to achieve).

So, I guess another way to put it, is it possible to front-load compile-time optimizations for certain LISP s-expressions, so that when the s-expression is evaluated, optimized machine code can be generated?

Can anyone give me the Cliffs notes on copy/paste on a MacIvory 2 with the Mac keyboard (w/overlay). I'm trying to copy and paste in Zmacs. I found a way to do it by selecting (underlining) text and then "kill"ing it and "yank"ing it back, but that seems like a kludge. Is there a way to select text and copy/paste without killing first? Is there a way to use the copy and paste keys on the keyboard?

Thanks,

Win

I've always been fascinated by systems such as the old Symbolics Lisp Lisp Machines or the Xerox programming systems, like Smalltalk-78.

And although there are modern incarnations of Smalltalk which you can install on top of Linux, like Squeak, they entirely lack all the multi-media stuff of old Smalltalks (Squeak has more of it than Pharo, but it is still not a complete multi-media system).

In other words, I'm not just looking for a programming system, but more for a kind of subsystem similiar to these.

As far as Lisp is concerned Emacs might be closest, but it doesn't even come close to what old Lisp machines could do.

Any advice? Does anybody know of a Lisp or Smalltalk system as complete as the old operating systems?

Thank you in advance!

Best comment about Lisp, ever.

Looking to buy any Symbolics machine, I've been looking for a while but unable to find one.

Disclaimer: I'm aware that questions like "which lisp should I learn" and similar is frequently asked here in r/lisp. But I couldn't find any discussion regarding Lisp machines specifically.

I got an interest in Lisp machines, both historical and modern that is currently under development. Because of that I would like learn Lisp.

To my understanding Common Lisp is a fusion of all the major Lisp dialects that existed in the 1980s. I.e. if I learn CL I can understand the source code for historical lisp machines, and participate in the development of new ones like Mezzano[0] and ChrysaLisp[1].

Before I make a deep dive into Common Lisp I just want to make sure I haven't missed anything that would make me regret this decision later.

Is Common Lisp the best dialect for me to learn if I want to learn about and develop Lisp machines?

If not, what dialect should I choose and what's its pros?

[0] https://github.com/froggey/Mezzano

[1] https://github.com/vygr/ChrysaLisp

[I think this would be better posted over yonder in r/lispmachine, but that sub looks really inactive. Sorry if this is considered off topic.]

So, in light of 50 years of Unix this year, I had an idea for a presentation that I wanted to do, where I wanted to compare-contrast methodologies and norms of the Unix tradition against those of the Lisp Machines and associated community. I'd ideally like some way to 'microdemo' some of the Lisp Machine features, like being able to go to a function's definition, look at the online help, and other characteristic features. Would using Emacs as a stand-in to demonstrate these features be close enough? Or should I attempt to get some sort of Lisp Machine emulator running to better capture these features?

I have managed to procure a copy of Dan Weinreb's thesis: A Real-Time Display-Oriented Editor for the Lisp Machine. It has less information of the type I had hoped for, but I still found it worth reading. Given the expense, I can't recommend it to any others than to people especially interested in the history of Emacs and Lisp Machines. Below are some of my notes on parts I found interesting. I've provided some manually transcribed quotations, and have used ellipses and such to indicate omissions of bits I thought unnecessary for my purposes, and paraphrased a few omitted bits indicated with square brackets. I could easily have made typos though.

First, a few general words about the paper. I procured it from MIT Document Services. It is unlisted in their catalogue, but you can still request it by writing to them and specifically requesting it. I believe the delay in their cataloguing of it is due to questions of the legality of listing it without the (now unobtainable) permission of the author (deceased), though that is just my speculation. It is 34 pages long, including all front and back matter. It is missing a diagram, which I believe was lost in the microfilming process. Each page bears the date 31-JAN-79.

To forestall requests for me to provide copies to people: I am not going to do that, in part because MIT Document Services really exerted themselves to get this for me. Multiple people on their staff searched for it after I pestered them, and it was eventually found in an uncatalogued reel of microfilm. I certainly cannot justify denying them the paltry income that their existence must be in part justified by to distribute it in that way. However, if someone has a question they think might be answered by the thesis but which I have not talked about here, comment or send me a message and I will answer as best I can.

Here's the abstract:

> ZWEI is a real-time display-oriented editor, written for the Lisp Machine. It is display-oriented in that the text being edited is displayed on the screen at all times; it is real-time in that commands are executed as soon as they are given. The result is an extremely interactive and efficient kind of editing. This kind of editor has become very popular in widespread parts of the MIT computer community, and has been found to be easy to use yet extremely powerful. This thesis describes the user interface presented by ZWEI, and explains how ZWEI was implemented. An emphasis is placed on the way

I'm reading the wiki page for lisp, and an on the history section and it writes:

Lisp was first implemented by Steve Russell on an IBM 704 computer. Russell had read McCarthy's paper and realized (to McCarthy's surprise) that the Lisp eval function could be implemented in machine code.[11] The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, "evaluate Lisp expressions".

How was McCarthy evaluating lisp before?

So while at this point in time I'm saving up to get my own place, I would at some point looooove to get my hands on a Space-Cadet style keyboard. I'm an Emacs's user (probably like most of us here), and I would at some point like to set up Stumpwm for my personal computer so the possible keybindings for those with a Space-Cadet keyboard seems endless.

While there are the LMI-CADR Lisp Machine keyboards out there, I was curious if there are more modern versions to purchase that have the Greek, Hyper, Super, APL and Roman numeral keys.

I was also curious if there's any projects to create modern Lisp machines. Mainly because I'd think it'd be fun (once I hone my Lisp-fu) to create a sort of mini Lisp machine with the widely available single-board computers that are out there, if possible.