Symbolics Lisp Machine demo Jan 2013

Typically an advanced UI where one types into a REPL is called a 'Listener' in Lisp. Examples for Listeners: the MCL Listener, Genera's Listener, LispWorks Listener, the SLIME Listener and others. For an impression of a Genera Listener I would recommend to see Kalman Reti's Youtube video: ▶ this video He shows there the Lisp Machine Listener debugging/interacting with mixed Lisp and C code. MCL and LispWorks IDEs Listeners are running in an integrated editor. The running programming runs inside the development environment. SLIME's Listener uses an external editor (GNU Emacs) for the Listener. Genera has an integrated application as a Listener and that one is not based on an editor. That's also a significant difference if the Listener is an internal tool, compared to an externally attached tool. External: from a user point of view, I use an IDE and connect to a running Lisp. Internal: I use the IDE and spawn a new Listener window (which could be on another X11 screen in case of an X11-based GUI). Usually the integration with internal Listeners is higher, but they may be more fragile, since they share the process & UI with the running program. Using an editor as a base substrate has some advantages: one has usually better editing support in the Listener. But as Genera shows, a Listener does not need to run on top of an editor to be powerful. The Genera listener has for example full output recording, each listener is also a drawing plane and remembers all output and associates it with the displayed Lisp objects. That makes the interaction with code and data extremely convenient, a feature which is not provided by evaluating code from an editor buffer. SLIME provides a similar feature, but in a very limited way. The richer the Listener UI, the more of the interaction of the user will be in the Listener. Thus often an exclusive use of the editor to evaluate code is either a sign of a powerful editor integration or a weak Listener implementation. In Genera the Lisp listener is also not only a powerful data explorer, but also a shell with a lot of commands for exploring the Lisp system. A portable and in some ways slightly less polished / extensive version is the McCLIM listener. Example: link Also a Lisp might provide Listeners as panes of application frames. Thus an application window (either a tool of the IDE or any application GUI window) includes a corresponding Listener as a pane. As a simple example I can open a LispWorks Inspector and add a Listener pane. Any result from evaluation in the Listener will be displayed in a Inspector, with history.

If you are into Lisp Machines, this talk on Symbolics by Kalman Reti (who worked there) is worth watching (1h): link If you only have 15 minutes, he gives another demo here: ▶ this video He has another video where he does some actual hacking (smooth scrolling of sheet music for display while playing an instrument): link

On Oberon, Mesa/Cedar and Lisp Machines, the experience extends to the whole OS and any application, or REPL, not just a plain text editor. Althought I haven't mentioned, Smalltalk also provides a similar experience. Here are some videos that try to convey it, from my playlists, "Eric Bier Demonstrates Cedar" link "Emulating a Xerox Star (8010) Information System Running the Xerox Development Environment (XDE) 5.0" link "SymbolicsTalk28June2012" "SYMBOLICS S-PACKAGES 3D GRAPHICS AND ANIMATION DEMO" link "Symbolics Lisp Machine demo Jan 2013" ▶ this video The Native Oberon demos available at link

That's a good suggestion. Walking through a set of interactions is a solid idea. For what it's worth, there are some videos around of people actually doing it with Lisp and Smalltalk systems, and pjmlp already posted a pile of them elsewhere in this thread. I can add a few more: Kalman Reti walking through some interactions with a Symbolics LispM repl: ▶ this video Brian Mastenbrook demonstrating Interlisp's SEDIT structure editor in the Xerox Lisp environment: link Rainer Joswig (lispm here on HN) showing us a little bit of repl and Zmacs interaction on a Symbolics Lisp Machine: link Rainer again, showing some simple interactions with Macintosh Common Lisp, which was my daily driver for years: link Ruby programmer Avdi Grimm shows some things that he found cool about Pharo Smalltalk: link Dan Ingalls (one of the original authors of Smalltalk) in a 2017 demo of Smalltalk 76: link There are some other things I'd like to find for lists like this, but haven't been able to. In particular, a good demo of Apple's SK8 would be great. If you can imagine a full-color Hypercard that could crack open and reprogram absolutely everything on the screen, including the machine code that drew the window system's widgets, all in a repl while the code was live; in which you could grab an arbitrary widget and drop it on the repl window to get a live variable reference to the widget, and then inspect it, operate on it, and reprogram it, again, while everything continued to run; in which you could build new window-system widgets by snapping together shapes and telling them to become widgets; in which you were not limited to HyperTalk for coding and text strings for data, but had a full Common Lisp at your disposal plus a Minsky-style frame system for representing data and knowledge, then you have some idea of what SK8 was like.

There's this recent video showing a little of what the Pharo Smalltalk environment is like: link The video was made by a Ruby programmer, rather than an experience Smalltalker, so it's more a newbie showing you cool things he's discovered, rather than an expert showing the power of the system. On the other hand, there's this one: ▶ this video That one is an expert, Kalman Reti, showing some of what it's like to work with a Symbolics Lisp Machine. (It's not a real Lisp machine; they're all at least thirty years old now; this is an emulator running the old Symbolics OS on Linux). Go to YouTube and search for Rainer Joswig and you'll find a few video demos of Lisp Machines and MCL and so forth. Finally, here are a few images from about eighteen years ago, also from Rainer. They show various views of the Macintosh Common Lisp and SK8 environments. It's not an experienced user showing you around, but at least you can get some idea what the environments looked like: link

Since he did AI work in the 50's, probably a lot of his work was written in LISP or IPL, which had many of the concepts that LISP later used. Most of his high-profile inventions (Computer mice, Hypertext, Interactive Computers) were first commercialized on LISP machines in the 80s. LISP Machines also pioneered some other concepts such as windowing ystems, graphic rendering, modern networking, garbage collection, etc. There is a fun little demo on youtube here; ▶ this video . That shows off a LISP machine roughly as it was written in the 80s/90s.

IIRC that site is hosted on a Raspberry Pi running SBCL and CL-HTTP, if it could handle HN traffic it would be just magical. Since the website is not up I decided to fish for a video showing Open Genera stuff elsewhere to share with you fine folk: ▶ this video Unfortunately there is no easy way for we to play with open genera since its proprietary and expensive. The world would be a better place if this type of system popped up more often. For those interested in Lisp I recommend the book "Land of Lisp" link or if you're more like a Racketeer then "Realm of Racket" link

> A common refrain is that Emacs is an operating system (OS). This isn’t true, but what invites comparison to an OS is its ability to orchestrate applications and utilities above the OS kernel level. Only because Lisp Machines, or variations thereof didn't took off in the mainstream. "Symbolics Lisp Machine demo" ▶ this video "Emacs and Lisp" link While Emacs was forked by Lucid as XEmacs to make one of the very first ideas of LSP, nowadays most features have been integrated back into Emacs link "Lucid Energize Demo" link

SBCL REPL cannot do this on xterm, it needs a proper hosting REPL environment like SLIME, which is no wonder, given how Emacs came to be and the interaction with genera. Inline graphics from 1981, ▶ this video Or using S-PACKAGE used to develop Nintendo 64. link You are missing integration with live debugging, calling anything on the OS during a REPL session, e.g. OS APIs, calling into automation points of the OS, Can try out directly on the browser, courtesy of WebAssembly and recovery of Xerox PARC software, link Or get either Squeak or Pharo, and see how using the Transcript integrates with the whole platform Windows, with either PowerShell ISE, or its new VSCode integration, are the closest to these kind of experiences. To finalise with Xerox PARC view on UNIX, from 1989 "UNIX Needs A True Integrated Environment: CASE Closed" link

>My dream is to make everything visualizable at runtime. Check out demos of the old Lisp Machines, [1] is a brief overview demo, [2] links to a timestamp with a view of some simple diagramming, but I’ve seen TI-Symbolics beasts routinely display complex relationships in Lisp code on their massive (for the time) bitmapped screens. The limitation was the end user managing the visualization complexity. With open source llvm, clang and similar making available abstract syntax trees and even semantic analysis and type checking results, LLM’s assisting with decompiling binary blobs, and modern hardware (goggles, graphics cards, and so on), I sometimes wonder how close we can come to reproducing that aspect of the Lisp Machine experience on open source operating systems. [1] ▶ this video [2] link

> the ability to integrate different languages in one image is unique Somehow. It should be possible to load a C, Prolog and Python implementations into one sbcl image. The Symbolics Lisp Machine emulator I use comes with C, Pascal, Fortran, several Common Lisp variants, Lisp Machine Lisp in one image. Kalman Reti once gave a demo how to debug mixed Lisp and C code in a REPL on such a Lisp Machine: ▶ this video

The key thing about those type of systems was the ability to reach down into the system and edit the code of the system currently in operation. Here's a demonstration of Symbolics Open Genera (TM) 2.0, demonstrated running in a virtual machine. It is noted by the author of the video in the first minute or so that even in emulation, it is much faster than the original machines. - ▶ this video Oberon also had a similar attribute, in that they kept the names of functions to operate on objects visible. The same was true of the Canon Cat, Hypercard, Ted Nelson's Xanadu project, Smalltalk, and a number of other early computing systems. The main feature common to all of these systems is that they all preserve context. In Genera, Oberon, Canon Cat, Hypercard, and SmallTalk the source was always available. (as far as I know). In Xanadu, the main functionality of the web was present, but it wouldn't allow the broken links (and lost context) that now plague the web. I think a future platform could take code in a number of languages, compile it to an abstract syntax tree, but preserve the context required to recreate the source. In fact, it's reasonable that you could import a routine in a language you aren't familiar with, and reverse the compilation to get it expressed in an equivalent (but less elegant) form in your language of choice, along with the original comments. There's nothing stopping an open source project from taking elements of these existing systems and moving forward from that basis. It might be profitable to include ideas such as Coloring of the Source text to label intent, such as in ColorForth. Also, consider "Literate Programming" - Literate programs are written as an uninterrupted exposition of logic in an ordinary human language, much like the text of an essay, in which macros are included to hide abstractions and traditional source code. You could also add the ability to store graphics and other data along with the source code. Of course, if you are required to run code you didn't write and don't trust, your operating system must provide means to run it only against the files or folders you wish to let it operate on. The principle of least privilege needs to be supported at a fundamental level. This is one of the big shortcomings of the Unix model. Sorry it was a bit of a ramble, but this seemed to be a call for ideas, so I ran with it. PS: In the past, getting your vision of Computing required building a machine, and then getting it manufactured. Now it just requires that you make it work in a VM, Raspberry Pi, or web browser window. It is MUCH easier to try out and/or create alterative systems now that it has ever been in the past.