>Coalton strives to implement Haskell or ML-adjacent semantics (in the type system, for example) with Lisp syntax. "With" here meaning that it is both implemented in and written with Lisp syntax.

Not exactly. Coalton brings ML-style strong typing to Common Lisp. But Coalton code is also Lisp code.

The backend, thus, is Common Lisp, and it is available at all times, thus leveraging all its power.

I think I meant the same thing, but you said it much more clearly, thanks!

>No multithreading, I/O locks under GNUs/eww, glacial slow

All this would not happen if RMS had chosen Common Lisp to implement it...

RMS hates Common Lisp because it's a bit bloated (tons) and the closes to GNU Emacs written in CL it's Lem and it feels far slower than Emacs.

Ironically, the GNU system now needs hundreds of megabytes of installation just to compile C.

The bloat is not about the size (sbcl and ecl can be pretty slim for what they do), it's the spec.

To write down the full spec, you have to document everything in those hundreds of megabytes. That's going to run for thousands of pages.

If your spec is small but you have hundreds of megabytes of bloat, it means you're not even remotely documenting everything.

You are really wrong. The Common Lisp Hyperspecs weights very little in my machine. 2.2 MB compressed as a TGZ.

It's really docummented. But the standard compared to Scheme it's huge.

PD: 2.2MB as HTML text weights nothing. You don't need images. It's 16MB uncompressed. More than 1500 items. People often forgets how little plain text weights.

Bloated? Sure. But slower than emacs? Strong disagreement here.

I find Lem a lot snappier than emacs.

Not on my n270 Atom, even under SBCL.

Huh I wonder if it’s an Atom thing

>It’s really interesting reading about LISP machines but no-one’s building a new one

There have been two open source Lisp Machine OS created in the last 15 or 10 years.

However a big part of the power of the Symbolics/LMI machines was in the software itself (applications), and this is still propietary code.

To reimplement the Lisp Machine applications would take quite a big effort.

The LMI and MIT Lisp Machine source code is not proprietary since about 10 and 20 years respectively.

>SmallJS is file based, not image based, so you can develop in your favorite IDE

This project is nice, however if we don't have a specific, client-side IDE for interactive development, 70% of the power of Smalltalk is gone (one of the criticisms I give to Ruby)

How would one do to push changes to the web frontend (browser) without stopping the program ?

The Playground example in SmallJS actually does this a bit. You can compile arbitrary ST expressions within a running web page. Underneath HTML <script> nodes are created. But I didnt think it was worth it to create a fully live IDE. VSCode is very nice and compiling a change takes only a second or two, side effect free. :)

Google Chrome has a 'Workspace' feature that hotswaps code without reloading the page.

One could easily implement an Emacs (SLIME) plugin to "macroexpand" the (pseudo) expresion to real (concrete) Lisp code, and even to try again until the implementation satisfies you.

Then it becomes a concrete Lisp implementation and thus not unpredictable anymore.

Isn’t that just vibe coding with extra steps?

>I want C++ do exactly and only what the programmer specifies

Good luck with that.

Add Common Lisp to the list. And even Scala has fast compile times today.

>Lisp killer features were GC, good data representation, first class functions.

Lisp's killer feature is procedural macros that are extremely easy to write and debug.

Lua doesn't have such a thing, that's why Fennel was created.

Erlang also doesn't have such a thing, that's why LFE was created.

>To whoever down-voted me, please do explain how HMRs are comparable to Erlang's true hot code swapping or even Lisp's live redefinition.

based