[FigBug]

I think Lisp failed because it had no killer app. Most developers don't pick a language, they pick a project and the select the most appropriate language.

Web frontend -> Javascript

Unix / Linux -> C

Wordpress plugins -> PHP

Windows apps -> .Net

iOS -> Objective C / Swift

Android -> Java

In my entire career (25 years), I've never had a project that directed me towards learning Lisp. This pretty much leaves Lisp to the type of developer that seeks out new languages and is willing to spend the extra effort integrating, and that's a pretty small number of developers.

If Lisp was in the browser instead of Javascript, it would be popular no matter the complaints about the language.

[reikonomusha]

Was Pascal a failure? Lots of programs were written in it. It had killer apps. Lots of programmers learned it. It made its way into the education system.

Lisp might be viewed similarly. It’s not a fad and big companies don’t use it widely, but does that make it a failure?

Google uses Common Lisp. (They even host a style guide!) So does Rigetti Computing making quantum computers. So does/did DWave, another quantum company. There are a handful of companies that have existed between 15–30 years developing Lisp compilers (LispWorks, Franz Inc, etc). Lisp also seems to be making HN front page at least once a week.

[p_l]

Pascal had two killer apps.

First, it was used for teaching, like Java today. So you had a wide base of programmers knowing it.

Second, there was Turbo Pascal which made it an extremely popular language on PC platform (also used to have significant presence on Mac, but I'm less familiar there.

[canttestthis]

> Google uses Common Lisp

Which projects at Google use Common Lisp? I didn't even know it was an approved language.

[nine_k]

As a side note: Pascal was not a failure. Currently it is incarnated as Go, that has a clear succession line to Oberon, Modula-2, and Pascal.

(Free Pascal is also alive and kicking.)

[logicprog]

I guess, although in the case of Java I'm not too sure. It seems like what you're really pointing out isn't so much a killer app but a captive market. If programmers are forced to use a language, they'll use it, is basically what you're pointing out. But think about C++, or Python or Java(!) or any number of other languages that didn't actually have a captive audience or a killer app and still became popular--- interestingly, in one of the other comments they say that the "killer app" for Java is safety and GC. That doesn't sound like a killer app, that's a language feature.

What I'm getting at here is that it's pretty clear that language features are an integral part of what makes a language successful. In fact, apart from some extreme, extreme outliers like JS which just happen to be the most visible, features are the only deciding factors outside of luck (and marketing). So if you ask why a language isn't successful, saying that it doesn't have a captive audience isn't a very descriptive or helpful metric. Yes, without a captive audience or maybe won't be as successful as JS but that's not the real deciding factor at all.

Aside from a captive audience based killer app, projects don't lead to language choice necessarily. Why did the person who created Numpy choose Python? Python didn't have a killer app for that. They chose it because of language features.

So we're back to the OG question: in the arena where languages normally compete (besides outliers), LISP looks amazing, so why isn't it as successful as we'd expect? I'd honestly suggest it's just bad luck, no marketing, and a fragmented community.

Now, we could talk about why the LISP community is fragmented, and in this case I think it's due to too much of an emphasis on extending the language. DSL-building based programming paradigms are actually really effective, they're essentially what FP and OOP are all about. In OOP you build a custom type system and language to represent the problem. For FP you do the same, just with less internal state. LISP's only difference is it has more powerful abstractions for formalizing the process. The problem is they confused DSL building with language building and so multiple different general purpose dialects proliferated.

[pjmlp]

C++ had a captive market.

It was bundled by C compiler vendors early on during the 90's, and it was on the rise as all desktop vendors were jumping into it as the way to write GUIs on.

Mac OS, BeOS, OS/2, Windows, they were all moving into it.

Had it not been for the rise of C based FOSS and the respective free UNIX clones, and it would have spread even more.

[flavio81]

>Now, we could talk about why the LISP community is fragmented (...) The problem is they confused DSL building with language building and so multiple different general purpose dialects proliferated.

The Lisp community isn't fragmented. There are two main lisp dialects (Common Lisp and Scheme), three if you want to add Clojure, and each of them has a faithful community.

[vukonen]

I don't think anyone has "chosen" to implement Numpy (or any of the hundreds of C and C++ modules) in Python because of its language features. On the contrary, they specifically avoided using pure Python because of its low performance and opted for more performant languages used through FFI.

The reason people have gone through the effort to implement those modules is absolutely because of "captive audience based killer apps" which for Python were ML and scientific computing. And while Python is decent in its role as a glue language, it succeeded mostly by being easy to pick up and very forgiving, which shouldn't be the main factors for choosing a language for anyone who is a software engineer and not a scientist.

[goto11]

Yeah, we geeks like to think the concepts and technical design of a language in itself is what makes or breaks it. But JavaScript could have been similar to BASIC or it could have been similar to Scheme - people would have grumbled but used it regardless. Objective-C was considered a pretty obscure niche language until the iPhone made it mainstream.

The article cites fragmentation as the reason Lisp didn't become mainstream. But consider SQL - a severely fragmented language. Each implementation have major incompatibilities with every other. But it is still ubiquitous and rules its niche.

[melling]

Scheme was almost that language of the web. Unfortunately, politics prevented that:

https://www.reddit.com/r/programming/comments/b7khq2/i_just_...

[BenoitEssiambre]

That's interesting. The author of Javascript wanted something lisp like. That must be why Javascript feels a bit like lisp to me with functions and closures being primary building blocks, notwithstanding the recent misguided attempts at making Javascript look more imperative with promises and the like.

I think there is something to the argument in the article about Lisp being too expressive and allowing developers to have too different styles making it difficult to read other peoples code. I wonder if another part of the problem with Lisp is that newbie developers struggle to follow continuation-passing style programs. This would explain why the promise crutch is so popular in Javascript.

I don't think it's the brackets that people dislike, it's having to understand the layers of scoping and closures that the brackets imply. Once you get used to it though it becomes very powerful.

[username90]

We don't know that, it is very likely that Mozillas language would never have become standard if it was scheme instead of Javascript.

[duckqlz]

> I think Lisp failed because it had no killer app.

As a vim user I love to think of all of the emacs peoples' heads exploding when they read lisp has no killer app. However it should be noted that lisp still has strong use cases in education and language design and even if not commonly used in industry its principles and design ideas come through in many modern languages.

[DonHopkins]

What do you mean? Emacs Lisp doesn't even have explode!

    (explode 'head)

    Debugger entered--Lisp error: (void-function explode)
      (explode 'head)
      eval((explode 'head) nil)
      elisp--eval-last-sexp(t)
      eval-last-sexp(t)
      eval-print-last-sexp(nil)
      funcall-interactively(eval-print-last-sexp nil)
      call-interactively(eval-print-last-sexp nil nil)
      command-execute(eval-print-last-sexp)

[dukoid]

Didn't they sell ITA again?

[wellpast]

Android -> Java? Java dominated well before mobile.

Also JVM languages are surging even though none have a specific killer app.

But Clojure is still niche. And is the most powerful/simple of them all. I think there’s something else going on, too much power & simplicity in a language doesn’t yield to mass appeal - why?

[Izkata]

Java's big thing was "same code, run everywhere". Even before Android, apps and games on my 2002 flip-phone were written in Java Micro Edition.

[grumpy8]

Yeah, that's a great way to look at it. Just to add to your point, why in hell would someone use Emacslisp? Well, it has a killer app (Emacs / org-mode / etc.) and people learned and used it.

I wonder if ClojureScript -> [Node, Web-js] is how lisp will be saved? Or maybe lisp doesn't need to be saved and it'll always be this non-mainstream language. (To be clear: I say non-mainstream but I don't mean it negatively.)

[c256]

I think you’re on to something, but maybe missing a historical detail: Lisp had a killer app: AI.

Unfortunately, the massive investment of time, money, attention, etc that went into Lisp and AI came too early, faltered, and left both high and dry for a few decades. It’s called “AI Winter”.

[ksec]

Thank You, Which is basically my economic theory of PL that I have been trying to explain across to many people.

An ecosystem forces you to program in a language, as long as the ecosystem grows in market value, it will require more developers, more people learning it and more jobs for it. A positive growing circle, and once it reaches a certain threshold it should become self sustainable, there will be interest from many parties to try and improve on it.

On the other hand, if a languages ecosystem does not reach that threshold, there will be doubt if new project should be built on it, there will be less opening for developers, less in demand means people are not learning it, market wants experience dev but experience dev would have moved on to other ecosystem. Lack of hireable Devs meant PM should choose something else that makes hiring easier. And the ecosystem shrink, what we call a languages is dying. It really isn't dying, it should be accurately described as shrinking. The Negative circle.

And in most cases languages lives on in other form. People call Ruby as Matz's Lisp.

[tsss]

I'd argue that none of those languages are the most appropriate for any problem at all. As long as the language itself is somewhat usable it's mostly the ecosystem (and hype) that counts: Libraries, editor support, build tools, etc.

[DocTomoe]

> In my entire career (25 years), I've never had a project that directed me towards learning Lisp.

emacs

[bryanrasmussen]

Either that or people know a language and they get given a new project which is generally not written in that language and they find some compiler/bridge/some other tool that allows them to write what they need to write in the language they are accustomed to writing in.

So why not choose a Lisp.

[hyperpallium]

Lisp had Symbolic AI, which got killed.

[V-2]

For what it's worth, the "Android -> Java" part is now obsolete. Especially as you do mention Swift in the context of iOS development. Kotlin is now the default language for Android, officially recommended ahead of Java.

[danem]

Ok... so why wasn't Lisp chosen over Javascript for the web, why wasn't Lisp chosen as the language for Android, iOS, or Windows?

[pjmlp]

Well, .NET GC was originally implemented in Lisp.

https://github.com/dotnet/coreclr/issues/401

And NeXTSTEP Interface Builder prototype was done in Common Lisp

https://en.wikipedia.org/wiki/Interface_Builder

https://vimeo.com/62618532

So it definitly had an influence on iOS and Windows.

Regarding Android, as Guy Steele puts it on his ClojureTV talk about Java.

"We were not out to win over the Lisp programmers; we were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp."

Finally, regarding the Web

https://thenewstack.io/brendan-eich-on-creating-javascript-i...

"He later calls Scheme “that beautiful research language I was tempted with.” But by the time he’d joined Netscape, they had a deal with Sun Microsystems, which was now pushing their newly-minted language Java. “And suddenly the story was, ‘Well, we don’t know if we want Scheme. We don’t know if we even need a little language like we wanted you to do. Maybe Java’s enough.'”"

[dehrmann]

That still doesn't explain Java's popularity as a backend language. Unless J2ME or Applets was the killer app.

[skybrian]

Yes, applets looked promising, but server-side, you might say Java was the Node.js of its time. Back in the early dot-com era, we were looking for a way for inexperienced programmers (us) to do Internet programming easily, and with its built-in threads and easy-to-use network libraries, Java looked pretty good. (And where it wasn't good yet, we thought Sun would improve it.)

This is around the time when Apache was popular with its original process-based concurrency model. You could waste a lot of memory running mod_perl with a pool of a hundred processes.

Java performance was pretty bad compared to C, but writing a select-based C server looked convoluted, and using threads in C looked obscure, non-portable, and bug-prone. We wanted a friendlier language than that.

[Secretmapper]

I would say cross platform apps, and an 'alternative to C/C++' was Java's killer app. Popularity as a backend language comes as a side effect of its general popularity (a la Node w/ Javascript, though there's something to be said about Node's 'different' approach)

[callmeal]

Java features that have yet to show up in other languages: Scalability - both horizontal and vertical. Memory utilization (you can have humongous heaps without having to worry about managing all that memory). Managability - easy to "divide and conquer": you can plop a jar and start using it right away. Something that's practically impossible in other languages. Third party ecosystem (both free/oss and paid). Speed. Java is one of the fastest managed languages.

Yes it is verbose, yes inexperienced developers do the wrong things, but it does a great job preventing you shooting yourself in the foot, and most importantly, once you have a stable codebase, it can keep running for months/years.

[ben509]

Enterprise -> Java + XML

They got in early, largely split the market with .NET

[FigBug]

I think Java was unique as it was the first language with a major corporation behind it and a large marketing campaign.

[carapace]

Also, to add to what everyone else is saying, you have to remember (or try to imagine) what it was like back then. When Java first came out it was hella cool! (Like MTV.)

[overgard]

Java was super heavily marketed

[soup10]

Java has good concurrency support and scales well.

[goto11]

Applets were the lever which propelled Java to a popular mainstream language.

[bloaf]

Probably the closest they got was Autocad's AutoLisp

[slim]

emacs -> lisp autocad -> lisp

[StreamBright]

https://www.jwz.org/doc/worse-is-better.html

[snazz]

Standard open-in-new-tab warning applies.