9 ms·

The Revival of Medley/Interlisp

154 points by samizdis 3y ago

nickt 3y ago
Here’s a short video showing the environment. https://youtu.be/QDrhdsrmtAQ https://youtu.be/QDrhdsrmtAQ
andygeorge 3y ago
https://news.ycombinator.com/item?id=38399305 https://news.ycombinator.com/item?id=38399305
- dang 3y ago
  Yikes! Merged hither now. Thanks!
hvs 3y ago
Relevant: https://online.interlisp.org/ https://online.interlisp.org/
worthless-trash 3y ago
> Common Lisp is Howl's Moving Castle. Common lisp isn't that big of a moving target, its also a standard which means that the standard isnt moving. In the vehicular comparison, I'd say its more like the filliping geepney (big heavy, shiny and bullies it way through heavy traffic).
- 7thaccount 3y ago
  The Conrad Barski lisp book used pictures of sheep and wolves to describe Scheme, Lisp, and Haskell iirc. Also cavemen to describe Fortran I think lol. I think he was trying to show scheme as being more elegant than common lisp, but also significantly less practical.
  - packetlost 3y ago
    I feel like Racket sorta changed the "practicality" story in many respects for Scheme. Not in the sense that Racket itself is practical, but the macro system is really good and inspired other Schemes like Gerbil that are more practical.
  - tomcam 3y ago
    [flagged]
  - vincent-manis 3y ago
    I would be able to speak to the allegedly “impractical” nature of Scheme if only I knew why Cisco hired Kent Dybvig, the principal developer of Chez Scheme. I would also like to know why Beckman Coulter Life Sciences supported the development of Swish, an extension of Chez Scheme that provides Erlang-inspired message passing. Gambit and Scheme have been used for health applications. Here's one paper on that subject, from 2013: https://ecem.ece.ubc.ca/~cpetersen/lambdanative_icfp13.pdf https://ecem.ece.ubc.ca/~cpetersen/lambdanative_icfp13.pdf I would mention the use of GNU Guile to build Guix, which has had considerable uptake. Guile has been used to build other Linux programs. Admittedly, Scheme isn't widely used. But impractical? No!
    - varjag 3y ago
      …if only I knew why Cisco hired Kent Dybvig… Nobody knows really but my suspicion it's not for moving Cisco codebase to Scheme.
    - lispm 3y ago
      The impression of being 'impractical' came from the Scheme reports, which for a long time, with the exception of the controversial R6RS, only standardized a relatively simple/limited language (example: no error handling).
    - 7thaccount 3y ago
      Probably impracticality via ecosystem. Chez scheme is fast, but more limited library wise than common lisp and much more limited than Python in that manner. Note that I like Chez scheme and think it's really cool.
mark_l_watson 3y ago
My company bought me a Xerox 1108 Lisp Machine running Interlisp D in 1982. I write a commercial product for that environment that we sold for $5K, and it was a lot of fun. I run the latest Medley releases occasionally just for nostalgia. For present day hacking enjoyment I go with SBCL Common Lisp+Emacs, or Racket, or Python when I need the ecosystem. Xerox really did a great job creating their Lisp Machines, a joy to develop on.
- 7thaccount 3y ago
  I often fantasize about a world where lisp or smalltalk machines took off instead of the Windows/Linux we have now. I know things weren't perfect, but it just seems like such a cool system and that we've evolved in a much less powerful direction.
  - ramenbytes 3y ago
    You're not alone. When someone asks "What OS do you prefer, Windows, Linux, or Mac?" my answer is: "none". Anyhow, back to dreaming. Someday maybe...
    - 7thaccount 3y ago
      That's a good way to put it. I don't want an OS in the common way of thinking of one. I want something a lot closer to the Xerox Alto, but maybe more with a command oriented language.
      - gumby 3y ago
        Did you program the Alto? It didn’t really have an OS — each app took over, like on a PC or Apple II. You might be thinking of the Alto’s descendants, the D-Machines, like the Dandilion (Star) or the research machines the Dolphin and the ECL Dorado. Those machines ran complete environments on the bare iron (Smaltalk, Interlisp-D, and Cedar/Mesa) but those environments included full O/Ses. The Smalltalk environment did initially run on the Alto, but Interlisp never did — too demanding.
mark_l_watson 3y ago
[dupe]
PaulHoule 3y ago
I think people came to the conclusion in the mid 1980s that you couldn’t really get ahead with a specialized “LISP machine” compared to an advanced general purpose processor, particularly when you put caching, pipelining and superscalarity into the mix. The genius of Common LISP was it had mechanical sympathy for the forthcoming ‘32-bit’ computers . Java was very much inspired by the CL spec defining a rich, efficient and implementable memory managed VM you could build over general purpose hardware with a lot of room for optimization and documenting that system very well.
- krmboya 3y ago
  I read in the article that it was possible to virtualize Medley/Interlisp on MS-DOS. If getting ahead means moving from Lisp Machines to MS-DOS then it's questionable what direction things were moving in. I get annoyed when I read things like the Plan 9 system would seamlessly works across several heterogeneous machines making it feel like one system, yet in 2023 I have jump through hoops to access files on my computer from my phone and vice versa yet both are in the same network
  - HKH2 3y ago
    > in 2023 I have jump through hoops to access files on my computer from my phone and vice versa yet both are in the same network Syncthing is pretty good unless you use iOS. Apple products tend to only have interoperability and user freedom because they're forced to.
- gumby 3y ago
  > The genius of Common LISP was it had mechanical sympathy for the forthcoming ‘32-bit’ computers “Forthcoming” is a bit anachronistic. By the time CL was being standardized in the early 80s 32 bit machines like the Vax were quite common, and there was plenty of experience from NIL and franzlisp. Also there was a decade of experience from the CADR which was a 32-bit machine. And CL itself was based mainly on the CADR’s Lisp, a descendant of MACLISP, which was developed on 36-bit machines like the PDP-6/PDP-10/PDP-20 which was the original Lisp machine, and also the progenitor of Interlisp, that also fed CommonLisp. MACLISP also ran on Honeywell’s 36-bit hardware under Multics.
dang 3y ago
Related: My encounter with Medley Interlisp - https://news.ycombinator.com/item?id=34300806 https://news.ycombinator.com/item?id=34300806 - Jan 2023 (49 comments) 2022 Medley Interlisp Annual Report - https://news.ycombinator.com/item?id=34100600 https://news.ycombinator.com/item?id=34100600 - Dec 2022 (11 comments) Interlisp Online - https://news.ycombinator.com/item?id=32621183 https://news.ycombinator.com/item?id=32621183 - Aug 2022 (9 comments) Larry Masinter, the Medley Interlisp Project: Status and Plans - https://news.ycombinator.com/item?id=25379238 https://news.ycombinator.com/item?id=25379238 - Dec 2020 (2 comments) Interlisp project: Restore Interlisp-D to usability on modern OSes - https://news.ycombinator.com/item?id=24075216 https://news.ycombinator.com/item?id=24075216 - Aug 2020 (24 comments)
DonHopkins 3y ago
>Scheme is an exotic sports car. Fast. Manual transmission. No radio. >Emacs Lisp is a 1984 Subaru GL 4WD: "the car that's always in front of you." >Common Lisp is Howl's Moving Castle. Scheme is the intersection of all Lisps. Common Lisp is the union of all Lisps. https://wiki.c2.com/?NetworkExtensibleWindowSystem https://wiki.c2.com/?NetworkExtensibleWindowSystem https://www.donhopkins.com/home/catalog/lang/NeWS.html https://www.donhopkins.com/home/catalog/lang/NeWS.html >Basically, X and NeWS seem to form the right and left brain halves of windowing systems. X is basic, fast (or should be) and analytical, NeWS seems to be what you should be using if you want something more creative than boxes with chars and/or line drawings in them of a fairly fixed nature. Right now people seem to be responding to each on that atavistic level. >X is a jeep wagoneer with all options including a tow ball if you can't fit it inside the cab, NeWS is a DeLorean turning magnificently on a stand in the main lobby of the Museum of Modern Art, the engine comes in kit form, diesel, gasoline, ethanol, any number of cylinders all available, actually the kit is just a big cube of steel, very high grade, and a textbook on modern engine design. >The X11/NeWS merge might very well end up to be the "long-awaited" station wagon version of the DeLorean, with the jeep hanging off the back on a newly attached brushed stainless steel tow ball, just in case. >-Barry Shein, Boston University, 6 Feb 1988, NeWS-makers@brillig.umd.edu
- lispm 3y ago
  > Common Lisp is the union of all Lisps Except it wasn't. Common Lisp was different from most Lisps in that it was a standard and not an implementation. Implementations were different, from small to large scale. The initial CLtL1 language definition was a small part of Lisp Machine Lisp with some stuff added in (type declarations, lexical binding, ...). CLtL1 lacked * a way to start or quit Lisp * command line arguments * memory management (like garbage collection, finalization, memory areas) * virtual machine * threads * stack groups * continuations * interrupts * fexprs * error handling * object system or any way to define extensible operations * user defined stream types * networking * internationlization features (like international character sets, multilanguage support, ...) * a higher level iteration construct * tail call elimination * stack introspection (backtraces, ...) * pretty printer interface * MLISP / RLISP syntax * library & source code management * 'weak' data structures * extensible hash tables * terminal interface * assembler * advising * source retrieval * pattern matcher * calling external programs * locatives * big floats * single namespace for functions and variables and more. None of that was in CLtL1. Much of that also is not in ANSI CL. Read through Lisp manuals (MIT Scheme, MacLisp, MDL, Lisp Machine Lisp, Interlisp, ...) from that time (when CLtL1 was published) and much of that existed. Implementations provided more. Just like, say, Interlisp-D (which also was an operating system with applications) provided much more than most Common Lisp implementations.
shrubble 3y ago
The Notecards application is interesting.
- lproven 3y ago
  [Article author here] It is. The whole thing is.
uticus 3y ago
> Developers from Fuji Xerox wrote a portable VM in C to run the environment on different host platforms, called Maiko. I'm always confused by the relationship of C and Lisp(s). Here the VM is written in C. Yet elsewhere there seem to be at least one good example of a Lisp compiler written in Lisp [0]. What was the reason for writing Maiko in C, versus Lisp "all the way"? [0] "The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT, and could be compiled by simply having an existing LISP interpreter interpret the compiler code, producing machine code output able to be executed at a 40-fold improvement in speed over that of the interpreter.[19] This compiler introduced the Lisp model of incremental compilation, in which compiled and interpreted functions can intermix freely. The language used in Hart and Levin's memo is much closer to modern Lisp style than McCarthy's earlier code. " https://en.wikipedia.org/wiki/Lisp_(programming_language)#History https://en.wikipedia.org/wiki/Lisp_(programming_language)#Hi...
- 5- 3y ago
  it'd be entirely possible to write the vm in lisp (there are plenty of good optimising lisp compilers, e.g. sbcl). however, typically you'd want the vm to be easily portable / buildable in new environments, and that's much easier to achieve with c. and it is likely just easier to write this kind of low-level code in c (however i know plenty of people who will gladly demonstrate otherwise). consider that the jvm et al are also written in c(++), for much the same reasons of practicality.
  - gumby 3y ago
    The C abstract machine is basically an overgrown PDP-11 at this point and most modern hardware is designed with that in mind with GPU and vector hardware being notable exceptions — and notably not being especially amenable to programming in C. It’s actually been an unfortunate and pernicious codependence IMHO.
- lispm 3y ago
  A Lisp and a compiler are two different things: Lisp is the whole thing and the Lisp compiler is just a component of a Lisp system. Now, one could write a virtual machine in Lisp, but usually one would write it in C or assembler, since that's what squeezes more performance out of the hardware and makes interfacing to the operating system 'easier' (threads, calls into the OS, memory management, interrupts, error handling, etc.). There are examples where (parts of) a virtual machine are written in Lisp. For example the Virtual-CPU emulator may be generated as C or assembler code from a Lisp program. There are also special versions of, say, the JVM written in Lisp to prove its correctness. Ideally one may want to have the core VM emulator written in assembler to reduce it to the most minimum hardware instructions per virtual machine instruction. The example you cited from 1962 is a Lisp compiler written in Lisp, compiled by itself, running in a Lisp whose runtime was written in assembler (IIRC).
mst 3y ago
Interlisp-D is quite fascinating even without the full environment. The spaghetti stack implementation makes continuation type things comfortably implementable and also runtime introspection of program state. It also has NLAMBDA as well as LAMBDA - the former is operative rather than applicative, i.e. it passes the argument expressions rather than evaluating them and passing the resulting values. Means you can do macro-like things at runtime if you have the need, though unlike e.g. Kernel Lisp and other fexpr-based lisps you don't get an environment object passed - because Interlisp is dynamically rather than lexically scoped a plain eval will DTRT so long as you haven't shadowed any of the relevant symbols. (I have a couple of Interlisp docs, plus a couple Kernel docs, plus some other stuff archived under https://trout.me.uk/lisp/ https://trout.me.uk/lisp/ if anybody's interested - there's probably better links elsewhere in the thread for the Interlisp things but I have a habit of keeping copies of stuff I know I'll want to refer back to)
- gumby 3y ago
  > The spaghetti stack implementation makes continuation type things comfortably implementable and also runtime introspection of program state. For a long time that spaghetti stack implementation was buggy because I don’t think it was really used. When I was at PARC working on 3-Lisp I wrote an emacs (being no fan of structure editing or the mouse) in Interlisp-D. I chose to make each command binding a closure (so you had all the proper mode context etc). That spaghetti light on the mouse cursor was basically perpetually on and the machine became unusable. I showed Masinter. It seems like nobody had ever thought of creating thousands of closures before. The bug was eventually fixed but by then I’d chosen a different strategy.
  - DonHopkins 3y ago
    I bet the bug was caused by a copy-and-pasta error!
    - gumby 3y ago
      I’m surprised given that the spaghetti stack is divinely inspired

154 points by samizdis 3y ago

nickt 3y ago

Here’s a short video showing the environment. https://youtu.be/QDrhdsrmtAQ https://youtu.be/QDrhdsrmtAQ

andygeorge 3y ago

https://news.ycombinator.com/item?id=38399305 https://news.ycombinator.com/item?id=38399305

dang 3y ago
Yikes! Merged hither now. Thanks!

hvs 3y ago

Relevant: https://online.interlisp.org/ https://online.interlisp.org/

worthless-trash 3y ago

> Common Lisp is Howl's Moving Castle. Common lisp isn't that big of a moving target, its also a standard which means that the standard isnt moving. In the vehicular comparison, I'd say its more like the filliping geepney (big heavy, shiny and bullies it way through heavy traffic).

7thaccount 3y ago
The Conrad Barski lisp book used pictures of sheep and wolves to describe Scheme, Lisp, and Haskell iirc. Also cavemen to describe Fortran I think lol. I think he was trying to show scheme as being more elegant than common lisp, but also significantly less practical.
- packetlost 3y ago
  I feel like Racket sorta changed the "practicality" story in many respects for Scheme. Not in the sense that Racket itself is practical, but the macro system is really good and inspired other Schemes like Gerbil that are more practical.
- tomcam 3y ago
  [flagged]
- vincent-manis 3y ago
  I would be able to speak to the allegedly “impractical” nature of Scheme if only I knew why Cisco hired Kent Dybvig, the principal developer of Chez Scheme. I would also like to know why Beckman Coulter Life Sciences supported the development of Swish, an extension of Chez Scheme that provides Erlang-inspired message passing. Gambit and Scheme have been used for health applications. Here's one paper on that subject, from 2013: https://ecem.ece.ubc.ca/~cpetersen/lambdanative_icfp13.pdf https://ecem.ece.ubc.ca/~cpetersen/lambdanative_icfp13.pdf I would mention the use of GNU Guile to build Guix, which has had considerable uptake. Guile has been used to build other Linux programs. Admittedly, Scheme isn't widely used. But impractical? No!
  - varjag 3y ago
    …if only I knew why Cisco hired Kent Dybvig… Nobody knows really but my suspicion it's not for moving Cisco codebase to Scheme.
  - lispm 3y ago
    The impression of being 'impractical' came from the Scheme reports, which for a long time, with the exception of the controversial R6RS, only standardized a relatively simple/limited language (example: no error handling).
  - 7thaccount 3y ago
    Probably impracticality via ecosystem. Chez scheme is fast, but more limited library wise than common lisp and much more limited than Python in that manner. Note that I like Chez scheme and think it's really cool.

mark_l_watson 3y ago

My company bought me a Xerox 1108 Lisp Machine running Interlisp D in 1982. I write a commercial product for that environment that we sold for $5K, and it was a lot of fun. I run the latest Medley releases occasionally just for nostalgia. For present day hacking enjoyment I go with SBCL Common Lisp+Emacs, or Racket, or Python when I need the ecosystem. Xerox really did a great job creating their Lisp Machines, a joy to develop on.

7thaccount 3y ago
I often fantasize about a world where lisp or smalltalk machines took off instead of the Windows/Linux we have now. I know things weren't perfect, but it just seems like such a cool system and that we've evolved in a much less powerful direction.
- ramenbytes 3y ago
  You're not alone. When someone asks "What OS do you prefer, Windows, Linux, or Mac?" my answer is: "none". Anyhow, back to dreaming. Someday maybe...
  - 7thaccount 3y ago
    That's a good way to put it. I don't want an OS in the common way of thinking of one. I want something a lot closer to the Xerox Alto, but maybe more with a command oriented language.
    - gumby 3y ago
      Did you program the Alto? It didn’t really have an OS — each app took over, like on a PC or Apple II. You might be thinking of the Alto’s descendants, the D-Machines, like the Dandilion (Star) or the research machines the Dolphin and the ECL Dorado. Those machines ran complete environments on the bare iron (Smaltalk, Interlisp-D, and Cedar/Mesa) but those environments included full O/Ses. The Smalltalk environment did initially run on the Alto, but Interlisp never did — too demanding.

mark_l_watson 3y ago

[dupe]

PaulHoule 3y ago

I think people came to the conclusion in the mid 1980s that you couldn’t really get ahead with a specialized “LISP machine” compared to an advanced general purpose processor, particularly when you put caching, pipelining and superscalarity into the mix. The genius of Common LISP was it had mechanical sympathy for the forthcoming ‘32-bit’ computers . Java was very much inspired by the CL spec defining a rich, efficient and implementable memory managed VM you could build over general purpose hardware with a lot of room for optimization and documenting that system very well.

krmboya 3y ago
I read in the article that it was possible to virtualize Medley/Interlisp on MS-DOS. If getting ahead means moving from Lisp Machines to MS-DOS then it's questionable what direction things were moving in. I get annoyed when I read things like the Plan 9 system would seamlessly works across several heterogeneous machines making it feel like one system, yet in 2023 I have jump through hoops to access files on my computer from my phone and vice versa yet both are in the same network
- HKH2 3y ago
  > in 2023 I have jump through hoops to access files on my computer from my phone and vice versa yet both are in the same network Syncthing is pretty good unless you use iOS. Apple products tend to only have interoperability and user freedom because they're forced to.
gumby 3y ago
> The genius of Common LISP was it had mechanical sympathy for the forthcoming ‘32-bit’ computers “Forthcoming” is a bit anachronistic. By the time CL was being standardized in the early 80s 32 bit machines like the Vax were quite common, and there was plenty of experience from NIL and franzlisp. Also there was a decade of experience from the CADR which was a 32-bit machine. And CL itself was based mainly on the CADR’s Lisp, a descendant of MACLISP, which was developed on 36-bit machines like the PDP-6/PDP-10/PDP-20 which was the original Lisp machine, and also the progenitor of Interlisp, that also fed CommonLisp. MACLISP also ran on Honeywell’s 36-bit hardware under Multics.

dang 3y ago

Related: My encounter with Medley Interlisp - https://news.ycombinator.com/item?id=34300806 https://news.ycombinator.com/item?id=34300806 - Jan 2023 (49 comments) 2022 Medley Interlisp Annual Report - https://news.ycombinator.com/item?id=34100600 https://news.ycombinator.com/item?id=34100600 - Dec 2022 (11 comments) Interlisp Online - https://news.ycombinator.com/item?id=32621183 https://news.ycombinator.com/item?id=32621183 - Aug 2022 (9 comments) Larry Masinter, the Medley Interlisp Project: Status and Plans - https://news.ycombinator.com/item?id=25379238 https://news.ycombinator.com/item?id=25379238 - Dec 2020 (2 comments) Interlisp project: Restore Interlisp-D to usability on modern OSes - https://news.ycombinator.com/item?id=24075216 https://news.ycombinator.com/item?id=24075216 - Aug 2020 (24 comments)

DonHopkins 3y ago

>Scheme is an exotic sports car. Fast. Manual transmission. No radio. >Emacs Lisp is a 1984 Subaru GL 4WD: "the car that's always in front of you." >Common Lisp is Howl's Moving Castle. Scheme is the intersection of all Lisps. Common Lisp is the union of all Lisps. https://wiki.c2.com/?NetworkExtensibleWindowSystem https://wiki.c2.com/?NetworkExtensibleWindowSystem https://www.donhopkins.com/home/catalog/lang/NeWS.html https://www.donhopkins.com/home/catalog/lang/NeWS.html >Basically, X and NeWS seem to form the right and left brain halves of windowing systems. X is basic, fast (or should be) and analytical, NeWS seems to be what you should be using if you want something more creative than boxes with chars and/or line drawings in them of a fairly fixed nature. Right now people seem to be responding to each on that atavistic level. >X is a jeep wagoneer with all options including a tow ball if you can't fit it inside the cab, NeWS is a DeLorean turning magnificently on a stand in the main lobby of the Museum of Modern Art, the engine comes in kit form, diesel, gasoline, ethanol, any number of cylinders all available, actually the kit is just a big cube of steel, very high grade, and a textbook on modern engine design. >The X11/NeWS merge might very well end up to be the "long-awaited" station wagon version of the DeLorean, with the jeep hanging off the back on a newly attached brushed stainless steel tow ball, just in case. >-Barry Shein, Boston University, 6 Feb 1988, NeWS-makers@brillig.umd.edu

lispm 3y ago
> Common Lisp is the union of all Lisps Except it wasn't. Common Lisp was different from most Lisps in that it was a standard and not an implementation. Implementations were different, from small to large scale. The initial CLtL1 language definition was a small part of Lisp Machine Lisp with some stuff added in (type declarations, lexical binding, ...). CLtL1 lacked * a way to start or quit Lisp * command line arguments * memory management (like garbage collection, finalization, memory areas) * virtual machine * threads * stack groups * continuations * interrupts * fexprs * error handling * object system or any way to define extensible operations * user defined stream types * networking * internationlization features (like international character sets, multilanguage support, ...) * a higher level iteration construct * tail call elimination * stack introspection (backtraces, ...) * pretty printer interface * MLISP / RLISP syntax * library & source code management * 'weak' data structures * extensible hash tables * terminal interface * assembler * advising * source retrieval * pattern matcher * calling external programs * locatives * big floats * single namespace for functions and variables and more. None of that was in CLtL1. Much of that also is not in ANSI CL. Read through Lisp manuals (MIT Scheme, MacLisp, MDL, Lisp Machine Lisp, Interlisp, ...) from that time (when CLtL1 was published) and much of that existed. Implementations provided more. Just like, say, Interlisp-D (which also was an operating system with applications) provided much more than most Common Lisp implementations.

shrubble 3y ago

The Notecards application is interesting.

lproven 3y ago
[Article author here] It is. The whole thing is.

uticus 3y ago

> Developers from Fuji Xerox wrote a portable VM in C to run the environment on different host platforms, called Maiko. I'm always confused by the relationship of C and Lisp(s). Here the VM is written in C. Yet elsewhere there seem to be at least one good example of a Lisp compiler written in Lisp [0]. What was the reason for writing Maiko in C, versus Lisp "all the way"? [0] "The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT, and could be compiled by simply having an existing LISP interpreter interpret the compiler code, producing machine code output able to be executed at a 40-fold improvement in speed over that of the interpreter.[19] This compiler introduced the Lisp model of incremental compilation, in which compiled and interpreted functions can intermix freely. The language used in Hart and Levin's memo is much closer to modern Lisp style than McCarthy's earlier code. " https://en.wikipedia.org/wiki/Lisp_(programming_language)#History https://en.wikipedia.org/wiki/Lisp_(programming_language)#Hi...

5- 3y ago
it'd be entirely possible to write the vm in lisp (there are plenty of good optimising lisp compilers, e.g. sbcl). however, typically you'd want the vm to be easily portable / buildable in new environments, and that's much easier to achieve with c. and it is likely just easier to write this kind of low-level code in c (however i know plenty of people who will gladly demonstrate otherwise). consider that the jvm et al are also written in c(++), for much the same reasons of practicality.
- gumby 3y ago
  The C abstract machine is basically an overgrown PDP-11 at this point and most modern hardware is designed with that in mind with GPU and vector hardware being notable exceptions — and notably not being especially amenable to programming in C. It’s actually been an unfortunate and pernicious codependence IMHO.
lispm 3y ago
A Lisp and a compiler are two different things: Lisp is the whole thing and the Lisp compiler is just a component of a Lisp system. Now, one could write a virtual machine in Lisp, but usually one would write it in C or assembler, since that's what squeezes more performance out of the hardware and makes interfacing to the operating system 'easier' (threads, calls into the OS, memory management, interrupts, error handling, etc.). There are examples where (parts of) a virtual machine are written in Lisp. For example the Virtual-CPU emulator may be generated as C or assembler code from a Lisp program. There are also special versions of, say, the JVM written in Lisp to prove its correctness. Ideally one may want to have the core VM emulator written in assembler to reduce it to the most minimum hardware instructions per virtual machine instruction. The example you cited from 1962 is a Lisp compiler written in Lisp, compiled by itself, running in a Lisp whose runtime was written in assembler (IIRC).

mst 3y ago

Interlisp-D is quite fascinating even without the full environment. The spaghetti stack implementation makes continuation type things comfortably implementable and also runtime introspection of program state. It also has NLAMBDA as well as LAMBDA - the former is operative rather than applicative, i.e. it passes the argument expressions rather than evaluating them and passing the resulting values. Means you can do macro-like things at runtime if you have the need, though unlike e.g. Kernel Lisp and other fexpr-based lisps you don't get an environment object passed - because Interlisp is dynamically rather than lexically scoped a plain eval will DTRT so long as you haven't shadowed any of the relevant symbols. (I have a couple of Interlisp docs, plus a couple Kernel docs, plus some other stuff archived under https://trout.me.uk/lisp/ https://trout.me.uk/lisp/ if anybody's interested - there's probably better links elsewhere in the thread for the Interlisp things but I have a habit of keeping copies of stuff I know I'll want to refer back to)

gumby 3y ago
> The spaghetti stack implementation makes continuation type things comfortably implementable and also runtime introspection of program state. For a long time that spaghetti stack implementation was buggy because I don’t think it was really used. When I was at PARC working on 3-Lisp I wrote an emacs (being no fan of structure editing or the mouse) in Interlisp-D. I chose to make each command binding a closure (so you had all the proper mode context etc). That spaghetti light on the mouse cursor was basically perpetually on and the machine became unusable. I showed Masinter. It seems like nobody had ever thought of creating thousands of closures before. The bug was eventually fixed but by then I’d chosen a different strategy.
- DonHopkins 3y ago
  I bet the bug was caused by a copy-and-pasta error!
  - gumby 3y ago
    I’m surprised given that the spaghetti stack is divinely inspired