shop3 VS portacle

A lot has gone wrong in terms of achieving high adoption, but specifically about something going wrong with rallying around CL, I don't think anything went wrong. No more are Maclisp, Interlisp, Lisp Machine Lisp, Zetalisp, Franz Lisp, Portable Standard Lisp, Spice Lisp... They were all slain or subsumed by Common Lisp. (You might have seen Franz elsewhere in this thread; rather than continuing it Franz, Inc. just developed Allegro Common Lisp separately. Spice Lisp meanwhile changed to become a CL implementation, became CMUCL, which was later forked into the now most popular implementation SBCL.)

Le Lisp/ISLisp are interesting European competition that didn't fall in line, but I don't ever hear about them, I only know they exist/existed, they might nowadays be effectively dead for all I know. Emacs Lisp is probably the biggest success in not caving to CL. Not big enough to constitute anything "going wrong" though.

I think your perception is wrong in two ways. First is the idea that Scheme and Clojure are somehow "variants" or "dialects" of Lisp. Scheme was never a Lisp dialect, it was instead described as a "Lisp-like". Also notice neither Scheme nor Clojure even have "Lisp" in their name, unlike all those other languages that got eaten by CL. "Lisp" meant something, and "Common Lisp" unified that meaning and I think deserves to be synonymous with "Lisp"; many writers have treated it that way. But Common Lispers are giving up that fight, because it's tiresome but also an understandable confusion not helped by Scheme or Clojure's attempts at capitalizing on some primordial idea about the good name of Lisp or whatever drives them to associate with the term. (#lisp in Freenode used to be only for Common Lisp, now in Libera #lisp is for all Lisp-likes and CL has its own channel.) Anyway, Scheme and Clojure have happily had their own evolution and separate largely incompatible s-expressions. I don't think their continued existence is a flaw against CL any more than another random programming language would be. One aspect of Clojure that might sting a little is that its entire reason for existing was because the author couldn't win political fights about having CL in production instead of the JVM.

The second way I disagree with your perspective is on prevalence. Scheme has had some success in teaching (mostly thanks to SICP) though Common Lisp was/is also used similarly at various places, however I think that's hurt [Common] Lisp more than anything. (Basically CL gets taught like Scheme, and so whether CL or Scheme is used students come away thinking they "know Lisp" without ever really having seen its OOP power, its handling of types, its condition system, its easy-to-define macros, let alone the trivial things like LOOP or SETF that make imperative programming possible and easy. It's like C++ classes that teach it as C-with-classes, but worse.) Scheme has also had success as GNU's official extension language (with Guile, which goes a ways beyond standard Scheme to be useful) and you see Scheme pop up in places like GIMP plugins. Racket is the most successful modern Scheme, but it has gone waaaay beyond standard Scheme and slowly seems to be becoming as large as CL. Real stuff is made with it, not just education stuff, but I'm less familiar with what's going on. It may yet eat CL's lunch.

Clojure of course has been a rising star and has enjoyed a lot of success in real stuff. It's popular, it's fashionable, and in terms of projects-per-second your perception is probably right that it's more widely used than CL right now. Where I would draw disagreement is in total pound-for-pound code that's Out There. CL has the benefit of decades of existence, so for example https://www.ptc.com/en/products/creo/elements-direct has been developed for a long time and is made of several million lines of CL code, and that's just one project. If you only used "active" (i.e. someone executed it over last month) code perhaps there's enough Clojure out there now to be an interesting race though there's no way to really tell; if you allow for all the CL that has been written and is no longer run, I don't think there's any contest, CL has such a rich history. (A random application being Mirai https://en.wikipedia.org/wiki/Mirai_(software) with demo https://www.youtube.com/watch?v=-IRsYGfr4jo -- has there ever been a 3D modeling program written in Clojure? Will there ever be?)

https://github.com/azzamsa/awesome-lisp-companies is an ongoing collection of companies known to be using CL. In terms of "industries", right now quantum computing companies seem particularly drawn to CL. Symbolic math historically also, with Maxima and Axiom being modern still-working/developed code bases. (The latter is a million lines of literate CL.)

But drawing on legacy again rather than last-few-years stuff, an old quote by Kent Pitman seems relevant: "Please don't assume Lisp is only useful for Animation and Graphics, AI, Bioinformatics, B2B and E-Commerce, Data Mining, EDA/Semiconductor applications, Expert Systems, Finance, Intelligent Agents, Knowledge Management, Mechanical CAD, Modeling and Simulation, Natural Language, Optimization, Research, Risk Analysis, Scheduling, Telecom, and Web Authoring just because these are the only things they happened to list." We can of course add more things to the list if that would help, like Mars Rovers or video games, https://news.ycombinator.com/item?id=9510945 has a few more, in recent news I learned about https://www.reddit.com/r/Common_Lisp/comments/osnsgz/intels_... and https://github.com/shop-planner/shop3 was open-sourced in 2019. Lisp is in a lot of places all over the world (it's had quite a legacy in Japan even), but not the most fashionable stuff, so it's also understandable that many people haven't heard about it, realized they're using it, or heard people talking about it.

here's an example from the shop3 planner which implements the macro's behavior in its expansion, rather than as a call-with- function:

I agree that it's a hurdle.

Portacle, https://portacle.github.io/ , is a way around config and whatnot, lowering the threshold a little.

Reminder that Portacle is a way to try Common Lisp (and its tooling!) in a portable, self-contained way, on all platforms.

https://portacle.github.io/

Thanks for your work! I can definitely see how your project improve CL's accessibility. Not sure if you're aware of the Portacle project, but I think there is an opportunity merging two projects together.

Also it is not much of a kit either since the user is left to install all the tools on their own. User who wants an easy to start kit with Emacs baked in is much better using Portacle or clean Emacs, or some of more polished Emacs distributions like Doom or Prelude together with Roswell for the "kit" part.

Then there's Portacle, a portable Emacs with SBCL, Quicklisp and Emacs goodies (magit, file-tree…) pre-installed. https://portacle.github.io/

There are some updates about Portacle last year. The latest is 1.4c Pre-release. https://github.com/portacle/portacle/releases Without Mac, can not verify it.

See also Portacle: https://portacle.github.io/ It is a portable Emacs that is ready-to-use for CL: it comes with Slime, some Emacs packages, Quicklisp and git.

Others have covered the language, but you'll also want tooling. An easy one to get started with is Portacle. It's a Lisp compiler, emacs with Lisp plugins, QuickLisp package manager, etc. so you don't have to spend time setting it all up.

1) I also love VSCode ... but for Lisp Emacs really is so much better. Look at Portacle. It basically is Emacs that's well configured for Common Lisp with SBCL right out of the box. You'll have to learn how SLIME work (the shortcuts to recompile running Lisp, etc).