Hash table literals.

SBCL is written in C and have FFI baked in

http://www.lichteblau.com/sbcl/doc/manual/sbcl/Foreign-Funct...

Maybe it’s too much work to write a full lisp vm in another language when it’s easier to write a loader.

Nowadays, historically Lisps have had the primitive forms written in Assembly and everything else bootstrap.

> SBCL is written in C

That's not quite right.

Coming from Ruby, wanting to learn a Lisp, there are so many things in Clojure that make the language much easier for me to understand, compare to other Lisps. Simple things like first/rest vs car/cdr make it much more ergonomic and easy to grok, IMHO.

Yeah I alluded to this in my comment, but I think the dict literals just make for a much easier on ramp for someone familiar with Python or JS (or JSON, which is increasingly unavoidable for even C++ devs like me).

There's first, second... tenth and rest in CL too. My 0.0002c.

The convention is to use car and cdr with cons cell structures that are not lists.

Nothing will ever be a base for lisps because theyre too malleable and the temptation ro create your own is too high

Anyway my recent favorite is Carp:

https://github.com/carp-lang/Carp

Serious projects in it? Zero

Same, I needed a Lisp that was typed for the AI era where Clojure's dynamism didn't fit the bill. Carp was a perfect fit, and I managed to create a few projects with the help of Deepseek

All Clojures are Lisps, but not all Lisps are Clojures. :)

It's immutable, has bracket syntax for data structures, and most of its standard library has very sensible naming and nil-sentinel conventions. The result is that it's astonishingly easy to read and write. The data structure sharing under the hood also keeps it performant. Finding and obtaining packages with its build systems is also easy.

Scheme gets close but has some odd naming conventions and wild conventions for naming and obtaining packages. CL's entire library is full of incredibly odd names first established at the very advent of computing. Using them can be...dense.

the data structure literals are really pleasant to work with, and oh how I miss get-in and update-in in every other language (with all the ecosystem of functions that follow that pattern and are built to work with it)

Aren't get-in and update-in a poor man's lenses? I find similar abstractions in most functional languages.

The ecosystem of Java, .NET and the Web, and contrary to other guest programming language communities, they embrace their host platform instead of downplaying it, and talking about replacing it.

As such you get all the nice stuff that has made Lisp a great language, plus access to modern libraries.

Note that since Common Lisp there has not been another standard, and in what concerns Scheme, Dr Raket is more relevant. Also R7rs Large has been hanging on for years now.

My first lisp was Clojure. Was skeptical but willing to try. Within two days I was writing a new component for our stack wrapping parts of the Aws sdk to access sqs (years ago).

Since looped around and had semi serious spells of Racket (scheme++; one could say) and Common lisp - purchasing stacks of books along the way.

For me - Clojure was THE language that really taught me functional programming - there really isn’t anything mutable without significant contortions.

It is also just a really good standard library and full of interesting concepts like specs (as opposed to types), transducers and such.

I would say that common lisp still has some interesting, unique features like conditions, which is essentially what exceptions SHOULD have been. But Clojure has a LOT of bang for buck.

Finally, I would swear my most intelligent, high impact code has been written in clojure. There is something to be said for the decomposition of problems with higher-order functions and immutable data structures and a live REPL.

Clojure's data structure design & concurrency model is particularly great, and the host interop opens up options for pragmatic development.

Macros are less ergonomic than other lisps.

I am just sad core.async is just the same old CSP.

I want to scream every time I have to implement nacks in CSP. It has to be domain specific every time, since there are no first class events.

I do agree that clojure gets a lot right (like an actually well integrated STM layer), the choice to go with CSP seems like a missed opportunity.

clojure is the best lisp by far