I bet there is a valid argument that there’s nothing here of any commercial value anymore.
The industry has gone beyond “catching up” to surpassing the values of the Lisp Machine and Genera. Any grand ideas of this era have been considered, and either mined, reimplemented, and exploited or simply rejected as being past their time.
The lack of a Lisp machine or environment like Genera is not holding Lisp (much less the entire modern family of Lisp-y languages) back. And modern IDEs are off the charts, even if they don’t check every single box of what Genera has to offer.
As an industry, we’ve not just stood on the shoulders of giants of the past like Genera, we’ve stepped off and up and moved ahead.
I’ve seen the Genera image that’s floating around, it ran in a VM of some kind. There’s a couple YouTube videos of demonstrations, and maybe I’ve seen the wrong ones, but I’ve just seen them as interesting but not necessarily compelling. It would be wonderful to see a thorough review from a modern perspective.
And, yea, they should set the system free. It’s pushing 50 years old, and we’re in “internet” time, so who knows how much that is in “No one knows you’re a dog” years.
When I got that leaked Genera image going in Linux I felt like I'd found a crashed UFO. It was incredibly inspiring and I don't think its true at all that we have surpassed it.
Why do I still have a clunky character-mode terminal instead of a Listener that can display rich text, images, mousable forms? Just think what we'd have today if we'd worked on that paradigm for 30 years instead of fetishizing the limitations of 70s minicomputers.
Why is it that when I type a command into said terminal and forget a parameter, I have to delete it, or open another window to type 'man', whereas on Genera I can hit <help> and view (rich, hypertext) documentation for a specific parameter, inline, while still typing in the command? That little feature was a revelation.
Genera's fluid, ergonomic developer experience is something we are turning away from more and more these days. Programming is increasingly surrounded by the most tedious bureaucratic and administrative work. The hoops I have to jump through before I can start creating something in a programming language are only increasing. If people had paid attention to Genera and to Lisp machines it wouldn't be like this.
And I've only mentioned surface aspects of the user experience. I haven't talked about being able to debug anything, or the idea that what look like applications are actually "substrates" that I can potentially use as APIs for my own work. We haven't scratched the surface yet.
But I took the time to get SLIME set up, with SBCL, and it seems like a completely different world. I’ve used languages with dynamic loading and REPLs before, and it seems like we still have something to learn from Lisp. Like, the experience is far from ideal—Lisp has its own problems. But it is just so damn nice to redefine a function in a running system, without having to then get the system back into the state that I need. I’ve used IDEs with dynamic code patching, and I’ve used Python systems that reload modules, but there have always been problems with the ergonomics.
Never understood this sentiment. I was editing functions without restarting the whole program using visual studio >15 years go and the ergonomics were great: I just click the line number next to the function, edit what I need to edit, and click continue to use the new function.
I’ve used that before, but the Lisp stuff still feels a lot better. I’m not just running a program and swapping out a function, but I’m using a REPL, some powerful introspection capabilities, a compiler, and a running system all together in a way that just works really nicely. I can add new files, import new libraries, and redefine structures. Objects that I print out in the REPL can be copied out and pasted directly into code. Rather than running the program and fixing the problems, you keep the system running the entire time you’re working on it. And the condition system provides a lot of help when you screw something up.
To be clear—I’m not making the argument that people should be writing programs in Lisp. Just that there are some things to learn from the way Lisp development works.
In the past, when I’ve used the various edit-and-continue tools, it felt it was just cutting some time out of the edit-compile-run cycle. The Lisp system feels more like a workbench, where you create fixtures to try things out while you are building the system.
Program Edit and Continue is a fragile self modifying C code hack that you would never dare try in production on a customer machine.
It doesn't simply replace a function binding; it actually replaces code and puts the instruction pointer of existing threads that were running that code into some similar location in the new code. (Which is pretty amazing, to be sure).
What's going on in Lisp code reloading is something a lot pedestrian; just new functions are replacing old ones. Thread which are in the middle of running the old functions continue with those ones. When the last thread is done executing a function, it can be garbage collected.
Ticketed and peer-reviewed fixes can be deployed live in production as if they were live code edits. Technically it is the same thing; it's just a process difference.
To be clear, I’m not describing “editing live in production” as the workflow. The workflow is editing code live on your development machine, committing the changes, and going through the normal code review + CI/CD pipeline you’d set up for any other project.
Something like Fix & Continue in Visual Studio is good for testing out smaller changes. By comparison, something like SLIME + Lisp is powerful enough to use for developing new features. The running system on your developer workstation is mostly synchronized with the source code on disk because the interface you use for making changes is the editor. This synchronization is not perfect, but that’s why you have your unit tests and CI/CD pipeline.
> puts the instruction pointer of existing threads that were running that code into some similar location in the new code
If you're implying that this isn't thread safe, you're wrong. Edit and continue works just like how you described Lisp code reloading. Works just fine in production if you're crazy enough to push a debug build.
I dunno why Lisp people keep advertising ancient and widely distributed tech as revolutionary. Eg have you looked at LLVM XRay? It's yet another "self modifying C code hack", except it's explicitly designed to work in production on release builds: https://llvm.org/docs/XRay.html
Generally Java and the JVM. The source code for J9 and Hotspot VM are taken from Smalltalk, which of course had a lot of mixing with Lisp. If you look at Mark Reinhold and John Rose (architects for the OpenJDK project), then you'll also see that they're Lispers.
I don't think the roots are going to be source code-based, but based on cultural transfer.
But the idea of Java being Lisp influenced is questionable. Though they had Guy Steele, who said something about bringing C programmers halfway to Lisp, pretty much the the only Lisp idea in Java is garbage collection.
The JVM is hostile against the efficient implementation of Lisp-like languages; it doesn't let you pack tag fields into pointer values.
Is it that big of a step to assume that old school Lispers know about Genera and have been influenced by it?
>But the idea of Java being Lisp influenced is questionable. Though they had Guy Steele, who said something about bringing C programmers halfway to Lisp, pretty much the the only Lisp idea in Java is garbage collection.
Java also has some dynamicism through classloaders and reflection.
>The JVM is hostile against the efficient implementation of Lisp-like languages; it doesn't let you pack tag fields into pointer values.
It's a good trade off for Java, pointer coloring is used by ZGC for example.
What happened was that a lot of Lisp/AI companies had to let people go. Amongst them from the Lisp Machine companies: LMI, Symbolics, TI, Xerox, ... but also Lucid and a few Expert System vendors. Some of these people were very experienced developers. There were only a few Lisp/Lisp-like companies/projects to go: Apple/Dylan, Harlequin, Franz, Clozure, ITA, ... They also worked on Java and .net infrastructure and languages.
Dan Weinreb wrote an object-oriented database at Symbolics -> Objectstore was founded by former Symbolics people. Their C++ database was said to be influenced by Symbolics Statice.
Patrick Dussud from TI went to Microsoft. Dave Moon went to Apple. Gary Palter worked for Clozure. Steele worked for SUN on language design (Java, Fortress, ...). Weinreb later went to ITA -> worked on the flight search engine written in Lisp. There are a bunch of other examples.
A bunch of language infrastructure or even language designs was influenced.
The industry has gone beyond “catching up” to surpassing the values of the Lisp Machine and Genera. Any grand ideas of this era have been considered, and either mined, reimplemented, and exploited or simply rejected as being past their time.
The lack of a Lisp machine or environment like Genera is not holding Lisp (much less the entire modern family of Lisp-y languages) back. And modern IDEs are off the charts, even if they don’t check every single box of what Genera has to offer.
As an industry, we’ve not just stood on the shoulders of giants of the past like Genera, we’ve stepped off and up and moved ahead.
I’ve seen the Genera image that’s floating around, it ran in a VM of some kind. There’s a couple YouTube videos of demonstrations, and maybe I’ve seen the wrong ones, but I’ve just seen them as interesting but not necessarily compelling. It would be wonderful to see a thorough review from a modern perspective.
And, yea, they should set the system free. It’s pushing 50 years old, and we’re in “internet” time, so who knows how much that is in “No one knows you’re a dog” years.