Hacker News Reader

Comment by jodrellblank | Hacker News Reader

Even today, Common Lisp is still one of the best choices for many applications.

Then why don't people build amazing and popular things with it? I don't mean one or two people build one or two things, but lots of people building lots of things.

Nobody uses it, but it's the best choice, can't both be true. And 'nobody uses it' is approximately true. It's not a mainstream JVM language or CLR language, it's not an AWS or Azure or Google Web Services language, it's not used for Linux Kernel, Windows, Oracle, *BSD, SQL databases, No-SQL databases, it's not used where Erlang is, it's not the research language Haskell is, it's not the fun esolang or the long-tail COBOL, it's not the new compiles-to-JavaScript, it's not the back of 3D games or VR engines, it's not behind Amazon's shop or used where Go is. It's not talked about in StackOverflow's most popular languages surveys, or most profitable languages for devs to learn, or most desired by employers. It's not an educational language like it once was.

Yet it's "one of the best choices".

I simply don't believe it. Any perceived advantages it has, in practise must be a wash.

View on HN

Too much fun to program in. Lisp makes it remarkably easy to extend the language into just what you want it to be...which means that Lisp programmers tend to spend most of their time extending the language into just what they want it to be rather than solving the problem. (Indeed, this is often touted as one of the benefits of Lisp...once you have a suitably well-adapted DSL, the problem solution follows naturally.)

Meanwhile, the Java or Go programmer is thinking "this is boring and ugly. Let me finish this problem as quickly as I can so I can go home." So they finish the problem as quickly as they can, and then it's done, and it ships. And people have an incentive to use it rather than tinker with it because nobody really wants to peek under the hood, and the people who do peek under the hood tend to be really dedicated and care a lot about the problem domain because why else would you put up with the language?

This one I can believe.

A few notes:

* Google actively develops one of the Lisp compilers. Google Flights powers Orbitz, Kayak, etc. That's Lisp.

* There are several Lisp compilers in active open source development.

* There's a graph database written in Lisp called AllegroCache. It's good enough to support a business (Franz) for more than a decade.

* Another company (LispWorks) also exists and has a large portfolio of clients.

* Lisp has been used to make entire operating systems. Ones of the past, and ones of now. (Of course, an OS needs a community. But where are real OS's with GUIs in other languages?)

* Lisp has been successfully used in my own career for embedded systems to control satellite acquisition systems to, most recently, quantum computing. (At real companies.)

Just because there's not this huge buzz around Lisp doesn't mean no one is using it.

I don't even code in Lisp, but I knew the Google Flights engine would come up, because it seems to be just about the only "serious" application ever written in Lisp. And it wasn't built by Google, but their acquisition ITA, which hails from Boston and MIT's Scheme reality distortion field. (And even MIT has stopped teaching SICP in Scheme...)

Emacs, ViaWeb, Macsyma, the DS1 Remote Agent, much of the autonomous navigation software for the Mars Rover before the Pathfinder mission... And I have built a number of small-scale web applications in Common Lisp. I'm running one of them in production right now.

And Yahoo! paid 49 million dollars of stock to throw the LISP in the trash and use something else instead.

It wasn't even worth them spending 1 million dollars - 2% of that price - on training people.

http://discuss.fogcreek.com/joelonsoftware/default.asp?cmd=s...

Right. And that decision was surely one of the reasons Yahoo is the runaway success it is today.

Are AutoDesk still using it?

It might be that it really is a big secret, and people are quietly using it and gaining advantages from it.

If that were the case, I would still expect to see lots of gushing blogs of leaks from inside hush-hush companies and people desperate to learn LISP posting "how do I replace strings in files in Common LISP" on programming forums, and "I learned LISP and doubled my salary" on Twitter.

Yet what you really see is Steve Yegge and "my EMACS code at Amazon was replaced with Java years ago" and "Facebook working on a new JavaScript thing" and "Microsoft working on a new JavaScript thing" and "Apple working on Swift" and "Fog Creek compile VBScript to PHP" and "rPi comes with Mathematica and Python" and so on and so on.

I wasn't saying that no one is using it. I was saying "if it was the best - as claimed - then there would be a buzz around Common LISP, because huge numbers of people would be using it".

Your points about your career are pretty interesting.

Lisp is old and it's unlikely that you see hype anytime soon. But you can see that Lisp derived languages like Clojure can generate minor hypes. Other new languages may even contain substantial pieces of Lisp influence. Examples would be Julia or R.

Generally the industry has problems reusing old/existing technology. See for example the Javascript domain, where new frameworks for web development pop up every week and the lifespan of frameworks is measured in months.

Instead of using/enhancing existing tools, there is a constant pressure to develop new stuff. Or take Apple with Swift. Instead of using Scala, Standard ML, OCAML, F# or Haskell, they developed a new statically-typed functional language.

It's the NIH syndrome at work. Everywhere. But it's also that tools are complex to learn, so people start new with simpler tools, they grow over time and after some time they are replaced with other stuff. If something gets updated in some incompatible ways, it already causes problems: some users are lost, some users will only use the old stuff, some only the latest stuff and some will try to use multiple versions. See Python.

Full Common Lisp is just too complex for most developers, but it has a life in many specialised and niche applications: CAD, some AI tools, music, robots (like the Roomba), planning/scheduling (crews, telescopes, ...), Expert Systems, verification of software and hardware, some maths stuff, ...

Since Lisp is only left being taught at a few universities, there are not many people able to develop with it. Even when it was taught, it was often only used to teach concepts like recursion and not programming. The younger Lisp programmers found it by themselves.

'Industry' sometimes often has no interest to diversify their programming tools. Many enterprise software shops currently (still) use Java: standardised, broad industry support, ... You won't successfully propose to them to use Lisp, even if the application would be better in some way. For example if the project fails, it certainly wasn't Java fault, because all the others are using it too. If you would use Lisp and the project would fail, it would be Lisp's problem: not enough people, little architecture experience, tools not broad enough, integration story too weak etc... Even it would be successful and in production, there would be a lot of pressure to rewrite it in some industry standard in the next product iteration.

> "if it was the best - as claimed - then there would be a buzz around Common LISP, because huge numbers of people would be using it"

There is no general 'best'. It's all relative to a domain, community, demands, legacy, fashion/hype, ...

Lisp is not more dead than usual. Yesterday there was a donation effort started for the Quicklisp library manager and it's now at $16606.37 .

Very good list of some issues that lead to "the new hotness" all the time. I had not thought of some of these; it's not totally brain-dead fanboyism.

One issue that (good) bosses have is that they cannot allow their business to be held hostage by one person. If that person quits (or dies), they have to be able to replace them. Esolangs are a hard sell on that basis alone, no matter how fit for use they may be.

I'd forgotten Clojure (and others!) - yes, Lisp is more popular than "things named Lisp". And, arguably, Clojure is popular enough these days that the argument in the previous paragraph doesn't really apply to it any longer. (Whether bosses know that is a separate issue.)

Then there's the claim by Guy Steele that, in creating Java, he dragged a bunch of C++ programmers "halfway to Common Lisp". (Lisp purists might concede some fraction considerably less than half...) Paul Graham says that the Lisp feature set is slowly taking over programming languages. Lisp may die but still conquer, or mostly conquer.

What Java mostly got from Lisp was parts of memory model and the managed memory, not so much on the language side. Smalltalk got that from Lisp too. Ruby also (the Ruby developer studied the Emacs Lisp implementation). Microsoft's CLR also. Actually parts of the early Microsoft .net CLR GC were written in Lisp and automatically translated to C.

But Java could not do a lot of things a typical Lisp implementation can do, sometimes with a good reason for that.

  * runtime compilation
  * loading of code (-> custom class loader)
  * garbage collection of code is sometimes difficult
  * saving/starting of memory dumps
  * fast startup times
  * tail call optimization
  * updating changed objects
  * calling error system -> Java has a terminating error system

For most of these problems some 'solutions' have been developed. On the language level the Java community experimented with some original Lisp stuff, too. But not much was added to the language, but at least they got lambda expressions (1958 in Lisp) and a first kind of multiple inheritance of code (around 1980 in Lisp via Flavors). Java soon will have a standard shell for incremental use ( https://blogs.oracle.com/java/jshell-and-repl-in-java-9 ) - that was around 1960 in Lisp. Now imagine when Macros will be added...

But generally knowing Lisp does not help you much with Java, since the language's OOP model is very different from the typical OOP in Lisp (see CLOS+MOP).

> But where are real OS's with GUIs in other languages?

There's this thing called Windows you may have heard of...

And, out of curiosity, what OS are you referring to?

> Just because there's not this huge buzz around Lisp doesn't mean no one is using it.

jodrellblank's claim was not that absolutely nobody is using it. The claim was, compared to how wonderful Lisp advocates claim the language is, relatively nobody is using it. If you compare the amount of software written in Lisp to the total amount of software written, and compare that to how wonderful Lisp is claimed to be, jodrellblank has a real point. And citing a handful (or several handfuls) of counter-examples does not refute the point at all.

>Nobody uses it, but it's the best choice, both can't be true

Sure it can. It is possible for both to be true, as long as developers don't pick languages rationally, which they probably don't.

There are a few biases at play. One is that people are only exposed to a subset of the languages that exist, which are those that are either used in industry, or are making the rounds in news. Another bias is that we like to pick languages based on familiarity. For example most of my college courses used imperative languages: Python, C++, and Java. From that experience I am quicker at thinking in terms of for loops than folds and maps. So when I try a language like Haskell or LISPs I think "That's neat!" but when faced with a deadline I switch back to something closer to my first languages.

It could be that I am the only one that thinks like this, and everyone else sits down and spends equal time on every language in existence, but I doubt it.

In any case at one point LISPs were popular, so why did they lose all of their momentum?

I also doubt it. But LISP dates back to 1958.

JavaScript is from 1995.

"I chose the language which exists" doesn't apply to the people in 1994 who could have had /thirty-five years/ of LISP experience (potentially) and yet still chose to write another language, in another language. And when Brendan Eich was in college around 1981, the tutors there could have had /twenty years/ of LISP experience, but weren't there to convince him that it was amazing.

Same with literally any language dating post-LISP, and I note that that covers most languages which are popular today.

"Programmers don't pick rationally" is fine on the small scale, but accross the entire industry, even among people who do love exploring programming languages, even among young entrepreneurial risk takers, even among companies in tough markets angling for any and every edge they can get over their competitors, in decade after decade, over problem domain after problem domain after problem domain, there is this empty howling wasteland of happy and productive people using not-LISP, writing world-conquering systems that do just-fine-thanks and the claimed benefits of LISP just don't seem to be making any noticable dent in anything.

Therefore, they are over-hyped.

You are overlooking a crucial fact: very often people who want to use Lisp are not allowed to by their management precisely because "no one uses it" and so the experiment never gets done.

I was the lead engineer on the first release of AdWords. I wanted to write it in Lisp, but I was not allowed to, being forced against my strenuous objections to to it in Java. So now AdWords is a Java success story rather than the Lisp success story it might have been not because Java is better (it certainly wasn't -- it was a disaster) but because my boss issued an edict.

This has happened to me many times in my career. The one time I was actually allowed to use Lisp in a project that I did not have direct control over (the DS1 remote agent) it was an overwhelming technical success. In fact, management tried and failed to get the software rewritten in C++, so this was actually a controlled experiment.

If that were the (only) issue, we ought to see Lisp used more in startups than in established businesses, because in startups, you don't have some manager who doesn't know Lisp and is managing to minimize is perceived (not necessarily actual) technical risk.

But in fact I'm not sure that we see more Lisp use in startups, either. That could be because they aren't taught it in school. (Many startup founders haven't had the chance to pick it up on the job. For that matter, many programmers haven't had the chance to pick it up on the job.)

On the controlled experiment: Why was that? I mean, it has to be possible to rewrite anything in C++ (Turing complete, and all that - but possibly at the price of Greenspun's Tenth Law). Was it because the people who tried didn't know anything about Lisp? (Were they working from the source, or from the spec, or from the program documentation?) Were they just not as good programmers as the Lisp programmers (and don't say "if they were as good, they would have been using Lisp" - that wasn't their assignment). Did they have less time, less resources? Why didn't/couldn't they do it?

It's all a viscous cycle going back to AI winter in the late 80's: DARPA stopped funding AI work, which meant that funding for Lisp work dried up, which meant that fewer people used it, which meant that fewer people learned it. Now, 30 years later, hardly anyone uses it, at least not directly. But it keeps getting re-invented again and again. You can't avoid re-inventing Lisp because it's part of the fundamental physics of computing. That is my frustration. People say that Lisp sucks, and then they proceed to re-invent it badly not even being aware that that is what they are doing.

As to why the re-implementation of the Remote Agent (it wasn't the whole thing BTW, just the planner) in C++ failed, it was a combination of factors. This was twenty years ago (holy cow!) and C++ compilers were nowhere near as mature then as they are now. There was only one compiler available for the flight hardware, and it was pretty unstable. But mainly it was Greenspun's tenth: the application did a lot of dynamic allocation (it was an AI search algorithms) which is something C++ is particularly not well suited for. They essentially had to re-implement Lisp in C++, and that was hard. Of course it would have been possible given more time, but we didn't have more time. The Lisp code was working, so that's what we flew.

Supposing the AI winter never happened, what is your perception of where Lisp would be now? Dominant? Large niche? Small niche, but larger than present?

I have no idea, and it doesn't really matter because we can't go back. I really don't want to dwell on the past, except insofar as we can learn lessons that inform the future. The point I really want to make is that Lisp is still a viable option today (Common Lisp and Clojure in particular) and I would like to see people give it a fair shake going forward.

I agree that claims for Blub (for any value of "Blub") are too often over-hyped. But don't make stuff up in the course of justifying your reasonable point against hype.

I met John McCarthy in 1977. In college, a professor (Ruth Davis, I think; SCU EECS department) brought in someone who taught Friedman's "The Little LISPer". By the time I got to Netscape, I had read SICP. I knew enough about LISP to be dangerous.

But as I've said many times, and Netscape principals have confirmed, the reason JS isn't Scheme is because Netscape did the Java deal with Sun by the time I hired on (after I was recruited with "come and do Scheme in the browser"), and that meant the "sidekick language" had to "look like Java".

There was no "chose to write". Netscape management gave the MILLJ order; Netscape source was C (mostly), JS ("Mocha") was supposed to go server-side via "LiveWire" as well as embed in Navigator, and I was a C hacker. These are the reasons for the new language and its first implementation language.

But don't make stuff up in the course of justifying your reasonable point against hype

Where's the fun in that? ;) No, but really - I apologize for claiming there wasn't enough general LISP enthusiasm around when you were at college to affect you, and for not actually looking into the history of JS before making statements about how/why it happened.

JS design being partly a pre-made business decision - that's something I really should have known by now.

> Nobody uses it

This application is written in 7+ million lines of Common Lisp

https://www.ptc.com/cad/elements-direct/modeling

https://www.youtube.com/watch?v=mJGytRaNvec

The video shows how Eterna uses 'PTC Creo Elements/Direct' to develop their watches. There are many other clients of that in various domains.

Also:

https://www.youtube.com/watch?v=4rD0zmA-Trc

Good cite.

(Although the fact that some people can make successful Common LISP software could just be that those people are exceptional enough to make successful software in any language, it doesn't bolster the claim that 'Common LISP is one of the best choices for many applications' very strongly).

Inmarsat uses a Lisp application (G2) to monitor their satellites and to provide a high level overview of the status of all Inmarsat services in real-time.

http://www.inmarsat.com

If you would run a Cement plant, an oil pipeline or a coal terminal in South Africa, then you might also be using G2 to control and diagnose technical processes in real-time.

The product used, written in Lisp:

http://www.gensym.com/wp-content/uploads/Gensym-l-G2.pdf

Then why don't people build amazing and popular things with it?

The reason is because "best" can have more than one meaning. Languages are usually only "best" at one thing, not for all things. In the case of many languages that people consider to be "best", they've been optimised for the development process (making it nice to write code in) rather than speed (C) or security (Ada) or a specific niche (R) or maintainability (not sure) or customisability (LISP). They're designed to make writing code more straightforward. Languages that are optimised to be easy to code with are the languages that tend to bubble up to the top when it comes to popularity contests because the more people who can access the language the more popular it's going to be.

There is an argument that Ruby is mostly LISP, so it could be said that lots of people use it very happily everyday.

> There is an argument that Ruby is mostly LISP, so it could be said that lots of people use it very happily everyday.

How is that? I thought Lisp's "killer app" was its extremely powerful macroing system. Does Ruby have an equivalent?

It has class level declarations which do the same thing.

I would go with that, in the sense that "here's a box of parts" is the most customisable way to solve a problem - yet not the best way for most people.

Except, even people doing exploratory stuff apparently aren't using Common-LISP.

Let me point to Slava from RethinkDB, who wrote blogs about how amazing LISP is and then went to found a new-software startup written in C++. Peter Norvig, AI researcher, who moved from LISP to Python.

And even your mention of Ruby - "Common LISP is the best langauge", then why is Ruby even needed? Why aren't those people happily using Common LISP? Simply because it wasn't actually any better, and was in fact worse than Ruby in whatever metrics.

Sure, in practice people's beliefs about languages can become self-fulfilling prophecies. And the thing about self-fulfilling prophecies is that they are actually true. For example, Javascript is tremendously useful even thought it is a horrible language from a technical point of view, it's just that the sheer weight of people using it because everyone else is using it results in enough infrastructure that you can get useful things done in in Javascript despite its (lack of) technical merits, not because of them.

And when JavaScript was becoming a thing, where was the better alternative written in LISP and the community of people who like better software supporting it?

Nowhere, that's where. Like in approximately all problem domains, whatever perceived benefits LISP has, doesn't seem to make it all that desirable.

Please. You pick a lowest-common-denominator language like Java or Golang so that you have a large pool of cheap, semi-sentient code monkeys to hire from.

If you choose LISP, you're actually going to have to expend a little bit of effort on identifying, recruiting, and retaining actually competent people. That's a problem when you're looking to put butts-in-seats (as is the case in my industry: defense).

That just pushes the problem back a couple of decades. Common-LISP is from 1984, GoLang is from 2007.

In twenty years, Common-LISP with all the advantage it supposedly has couldn't make anything that a 'code monkey' could use? Why not? Is it awful at writing tools?

Or is it that the alledged advantages of Common-LISP don't really make any difference in reality because they are over-hyped or even non-existent?

Note that I'm not saying "why did they pick one language over another", I'm saying "Common LISP can be the best tool for the job - yet they waited twenty years to use a 'worse' tool to implement a 'worse' tool". That doesn't make sense.

You are writing this comment in the lisp-based software. Yeah, I know, Hacker news is a simple software and could have been written in anything else, but, somehow, the author, who I've heard is very smart, thought that Lisp is the best pick.

And his secret to winning big was "write lisp software, have it bought out by another company who will rewrite it in a different language to make it popular and useful".

Really, if PG's "LISP, how to win big" was as compelling and important as he tried to state in that essay, every ycombinator company would be using LISP for their secret advantage over other companies.

Applicants would choose LISP because it's "better", LISP-based applications would be preferred because the applicants have an advantage, existing companies would be encouraged to LISP because it would help them do more for less employee numbers and YC would become a LISPy community of alumni.

I have no proof that this is not happening right now, but would you bet on it happening right now in secret?

Your logic assumes that young founders/developers are very proficient in many languages (including lisp) and they have perfect information for choosing. In reality, they use whatever crap they picked up hacking in high school. On top of that, the tools are only a part of the ingredients. However bad your platform is, at least it works, while most of the screw-up is hidden in business decisions - that's why every startup incubator's job is to help the youngsters not screw up business-wise. Tech is normally something up to the founders, most of whom have never heard of lisp.

Reply on news.ycombinator.com