SICL: A New Common Lisp Implementation

I suppose I somewhat despise the Common Lisp "way" of things so much so that it distorts my perception of it. A lot of old JPL stuff was written in Lisp, and what you said about resilience strikes a chord with me.

I think the things that really stimulate me the most are things that a small, refined, core language can provide. I've always considered it a benefit that R7RS has become smaller and also that history will not look favorably to R6RS, I thought it was the wrong move. The projects that matter the most to me and to my sensibilities for scheme are abstract and academic. Check out namin's staged-minikanren repo on GitHub. (On mobile, else I'd link you) That is one of the most fascinating pieces of technology ever produced by humankind, imo, and it's written in a simple, common scheme. I think it actually evaluates on Racket, but you can see most of the code tastes like regular Scheme.

If I said that Common Lisp wasn't good, I surely regret it and can admit my wrong.

I wouldn't call Racket the best scheme, but certainly the most well known, as you say. It evolved in parallel to it's vision of meta-languages, and that's something I would argue entirely catalyzed by having a small, simple, functional core of Scheme. Racket could just as well have been Lisp, and it'd look and feel different, but the same magic would be lurking beneath the surface. It'd probably execute a lot faster these days too!

Anyhow, thanks a lot for your insights.

I have a sense that any new standards process would have to work hard to defend against a number of distractions, such as forcing character encoding into the standard, the lure of JVM style compile once run anywhere (which has destroyed the ability for Clojure to bootstrap without maven), or attempts to reduce or remove certain warts that some users find annoying.

Many who don't know the history don't realize that the standard as it exists encoded the separate practices of many disparate groups into a single standard. This can be confusing for newcomers because they may encounter ways of doing things that are archaic but still in the language. Part of the challenge thus is not getting rid of things, but somehow figuring out how to communicate what have come to be understood as the better ways of doing things --- all without changing those parts of the standard.

I'm sure that the old lispers have fairly extensive lists of fundamental issues and improvements.

The short list that I have been able to compile from chance encounters with mentions of shortcomings includes implementation details, such as lexical O(1) jump tables, delimited continuations, proper tail call elimination, threads, extending dispatch macro syntax, and default precision for reading floats, and issues that almost certainly need more research and exploration, such as finding a solution to the CLOS action at a distance issue, CLOS dispatch on parametric types, something about static types, ways to alloc without gc, and many more things I am completely unaware of.

The Racket ecosystem has done quite a bit of research and implementation in many of these areas, but Racket lies at the far end of the lisp family from common lisp. Finding a way to take the more static and text based ideas from the ML/Racket end of the spectrum and make them accessible at the the dynamic image based Smalltalk/Interlisp end seems like something that could happen within the common lisp space more readily than elsewhere. There seem to be some fundamental questions about how late binding interacts with many other language features that do not have satisfactory answers.

All of this being said, I don't see the motivation for anyone in the space to spend the time on another standards process while so many ideas haven't been explored.

At this point it is about consensus among implementations. phoe got package local nicknames into all implementations, and that is a very major revision to the standard. So in practice it is happening.

Of course it did, was Clojure not released? — “And then there's Clojure, which has become what I always kinda thought Common Lisp should've tried to become.”.

I can't help but think that this is purely a game of names, not of existence and features.

In the age of multicore, the perception that everything is a list which lends to sequential processing it makes lists actually less appealing.

Guile is what I mainly use for hobby projects, it's pretty dang reliable and fast, Andy Wingo is a compiler genius and there's a lot of good internals walkthroughs on his blog.

Other than Racket, have you tried a lot of implementations?

  (asdf:initialize-source-registry
   '(:source-registry
     (:tree #p"/path/to/Second-Climacs/")
     (:tree #p"/path/to/SICL/")
     (:tree #p"/path/to/OntoLisp/")
     :inherit-configuration))