[bsder]

> It may also clarify why more powerful languages such as Scala, Common Lisp, Smalltalk, Haskell, etc, consistently fail to pick up steam.

Languages need a window of opportunity, and many of those squandered it.

Clojure won over Scala because at the time when people were loooking for an alternative JVM langauge, Clojure was more of a departure from Java and seemed to have better tooling (compile times and syntax support) than Scala.

Smalltalk and Common Lisp wasted their moment by not being cheap/free to people using micros in the 1980s.

Lisp, especially, very much wasted its moment with micros. The fact that no Lisper had the vision to dump a Lisp onto the bank switched micros (which makes GC really easy and useful) of the mid to late 1980s is a self-inflicted bullet wound. Lots of us hated doing assembly language programming but had no real alternative. This was a loss born of pure arrogance of Lispers who looked down on those micros as not being "real machines".

I weep for all the hours I wasted doing assembly language as a teenager that I could have been writing Lisp. How much software could have been written that would have been <100 lines of Lisp if only someone had written that tool?

[baobun]

...in what sense has Clojure actually won over Scala?

I see way more Scala in companies last ~5y and have the impression of its ecosystem being more robust. Not uncommon for greenfields. It's longer than that I even encountered an active Clojure codebase. This is from a data-engineer perspective.

Clojure may be more popular for some niche of app startups perhaps? We are in different "bubbles" I suppose.

EDIT: Data disagrees with you also.

https://www.tiobe.com/tiobe-index/

https://redmonk.com/sogrady/2024/09/12/language-rankings-6-2...

https://survey.stackoverflow.co/2024/technology#1-programmin...

[bsder]

I can't really speak to modern stuff, and it is certainly possible my memory is faulty. Scala was a PITA in the early 2000s and you were generally better served with something else if you could move off the JVM. Clojure came in about mid 2000s and seemed to be what a bunch of people stuck on the JVM but doing data processing were desperate to find.

My feeling was that a lot of Clojure folks moved on as the data processing stuff moved on from Java/JVM.

My impression has been that JVM-based languages have effectively been on a steady general decline for a while now. Java has fixed a lot of its issues; Kotlin gave the Java expats somewhere to go. And Javascript/Node along with Go drained out the general masses who didn't really want to be on the JVM anyhow.

However, it is interesting that Clojure has effectively disappeared in those rankings.

[baobun]

And yet it sees success in an actively developed project (OP).

I think both are challenging your notion of closing opportunity windows for programming languages (:

[igouy]

> Smalltalk and Common Lisp wasted their moment by not being cheap/free to people using micros in the 1980s.

Smalltalk and Common Lisp are not individuals.

"$99 Smalltalk Announced" 1986 InfoWorld Jun 30

https://books.google.com/books?id=Wi8EAAAAMBAJ&pg=PA11&dq=Sm...

[shrubble]

Lisps really only come into their own above a certain size/amount of resources. For early Lisp the PDP-11 with 2-4 MB RAM was considered to be nice. There were some Lisp implementations for the PCs but they suffered from the need for compatibility with older hardware.

[lispm]

> Lots of us hated doing assembly language programming but had no real alternative.

I kind of fail to see Lisp as an alternative to assembler on mid 80s micros.

Though, there were several cheap Lisps for PCs...

[bsder]

The bank switched memory architectures were basically unused in mid 80s micros (C128, CoCo3, etc.).

Lots of utility software like spell checkers and the like still existed. These would be trivial to implement in Lisp but are really annoying in assembler.

Lisp would have been really good relative to BASIC interpreters at the time--especially since you could have tokenized the atoms. It also would have freed people from line numbers. Linked lists work well on these kinds of machines. 64K is solid for a Lisp if you own the whole machine. You can run over a bank of 16K of memory for GC in about 50 milliseconds or so on those architectures.

Had one of the Lisperati evangelized Lisp on micros, the world would look very different. Alas, they were off charging a gazillion bucks to government contracts.

However, to be fair, only Hejlsberg had the correct insights from putting Pascal on the Nascom.

[lispm]

> Lisp would have been really good relative to BASIC interpreters at the time

I see no evidence for that. Lisp was a pain on tiny machines with bad user interface.

> 64K is solid for a Lisp if you own the whole machine.

I had a Lisp on an Apple II. It was a useless toy. I was using UCSD Pascal and Modula 2 on it. Much better.

I had Cambridge Lisp on an Atari with 68k CPU. It was next to unusable due to frequent crashes on calling FFI functions.

The first good Lisp implementation I got was MacScheme on the Mac and then the breakthrough was Macintosh Common Lisp from Coral Software.

> Had one of the Lisperati evangelized Lisp on micros

There were articles for example in the Byte magazine. Lisp simply was a bad fit to tiny machines. Lisp wasn't very efficient for small memory. Maybe with lots of work implementing a tiny Lisp in assembler. But who would have paid for it? People need to eat. The tiny Lisp for the Apple II was not usable, due to the lack of useful programming environment.

> Alas, they were off charging a gazillion bucks to government contracts.

At least there were people willing to pay for it.

[bsder]

> There were articles for example in the Byte magazine.

And they were stupid. Even "good" Lisp references didn't cover the important things like hashes and arrays. Everybody covered the recursive crap over and over and over ad nauseam while people who actually used Lisp almost always sidestepped those parts of the language.

> I had a Lisp on an Apple II. It was a useless toy. I was using UCSD Pascal and Modula 2 on it. Much better.

And yet UCSD Pascal was using a P-machine. So, the problem was the implementation and not the concept. Which was exactly my point.

> At least there were people willing to pay for it.

Temporarily. But then it died when the big money went away and left Lisp all but dead. All the while all the people using languages on those "toys" kept right on going.

[lispm]

> And yet UCSD Pascal was using a P-machine. So, the problem was the implementation and not the concept. Which was exactly my point.

My point is that implementations don't come from nothing. You can't just demand them to be there. They have to be invented/implemented/improved/... Companies at that time did not invest any money in micro implementations of Lisp. I also believe that there was a reason for that: it would have been mostly useless.

> Temporarily. But then it died when the big money went away and left Lisp all but dead. All the while all the people using languages on those "toys" kept right on going.

Lot's of toys and languages for them died.