We Need Lisp Machines

• clog

  150 1,429 9.6 Common Lisp

  CLOG - The Common Lisp Omnificent GUI

If you’re fine with ES3, there’s https://marijnhaverbeke.nl/cl-javascript/

Or parenscript: https://parenscript.common-lisp.dev/

Or CLOG: https://github.com/rabbibotton/clog

And, there’s always the option of writing an HTTP or websocket server and serving JSON.

I personally use the SLIME repl in emacs for a ton of things I used to use bash one-liners for and you can push it pretty far (this is an experiment, I’ve wrapped it up more nicely into my .sbclrc since):

https://twitter.com/fwoaroof/status/1502881957012668417?s=21...

• swank-client

  3 79 2.5 Common Lisp

  Common Lisp implementation of a Slime / Swank client.

> Honest question: how do you communicate between two Lisp processes on two different machines?

Depends what level of integration you want: custom tcp/udp protocols, HTTP and websockets are all pretty easy. But, you can also use something like this over a trusted network/vpn: https://github.com/brown/swank-client

• InfluxDB

  www.influxdata.com featured

  Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

  

• oil

  235 2,734 9.9 Python

  Oils is our upgrade path from bash to a better language and runtime. It's also for Python and JavaScript users who avoid shell!

  

I agree there aren't many practical alternatives to serialize -> wire -> parse, because that's how all storage and networking hardware works.

But I keep having this conversation with people who are mad at Unix (and Unix shell) and think there is an alternative. Some of them are just fantasizing like this post, but some of them are actively working in this direction.

One possible alternative is if the kernel grew a mechanism to pass linked data structures directly, instead of requiring serialization and parsing (a little like Go channels perhaps). I suppose you can kind of do that with shared memory -- but not really because copying is roughly equivalent to serialization.

This might sound like an unrealistic idea, but people are seriously arguing for them -- including the more radical idea in this post -- an entire machine in Lisp, with single address space (horrible idea).

----

The other more practical thing I'm arguing against in the post is a certain design of alternative Unix shell [1] that I've been seeing a lot.

The design is that basically that all the tools like 'ls' and 'rm' and even networking tools are expected to be statically linked into the shell binary.

And many of them pass structured data directly, specifically to get rid of serialization and parsing. There are at least 3 or 4 shells with this design.

My point is that this creates a "two-tiered" shell design and that composition is inhibited. In my mind the point of the shell, and the power of it, is to be situated within or "woven into" the OS. It interacts with everything on the system. It's not a "world" unto its own. You should be able to whip up a script in your favorite language and call it from your shell, and compose it with other tools you didn't write. You shouldn't be forced to "escape" the shell to call outside tools, or write algorithms in shell like you would write algorithms in Python or C. The shell is for coarse-grained composition and coordination.

[1] list here: https://github.com/oilshell/oil/wiki/Alternative-Shells

• mirage

  32 2,433 8.7 OCaml

  MirageOS is a library operating system that constructs unikernels

  

The Lisp machine of today is MirageOS: https://mirage.io/

A unikernel that throws out the legacy of Unix and starts fresh to build a library operating system, it's exactly what OP describes:

> With lisp machines, we can cut out the complicated multi-language, multi library mess from the stack, eliminate memory leaks and questions of type safety, binary exploits, and millions of lines of sheer complexity that clog up modern computers.

Even better, Mirage is programmed in OCaml, which is basically a statically-typed facade over Lisp (or Scheme). That's the modern Lisp machine of today. It even takes care of security nightmares like this:

> Everything worked in a single address space, programs could talk to each other in ways operating systems of today couldn’t dream of.

Because in the Mirage model is program is a separate OS image and they can communicate only over defined service interfaces.

Suggest a related project