How I lost my faith in Lisp (opens in new tab)

> (2) is an egotistical line of reasoning.

To be fair, at the time that reasoning was supported by a fair amount of data. To that point I had built a fairly successful career by doing (by my perception) very little work relative to my peers, and I ascribed that success to the leverage I got from using Lisp. I may have been wrong, but it was a defensible position given the available data at the time.

He's also occasionally on Hacker News:

http://news.ycombinator.com/user?id=lisper

Sometimes I make fun of Paul Graham.

I actually don't think that's the point of the article - it may be true, but it's not supported by the text or background story. This was written in 2002, and the author's tenure at Google was 2000-2001. That was pre-BigTable, I think it was pre-MapReduce, and it may even have been pre-GFS. Plus, Google's known for it's NIH syndrome - while there are a fair number of third-party libraries in use now, there weren't really in Google's codebase of 2000, which had just dumped many of the early frameworks they'd used for prototypes.

Rather, I think this is more evidence of the old "Good programmers will be productive in any language." The advantage that an expressive programming language like Lisp gives you is that it frees you to think about the problem domain and not worry too much about the details of the machine. However, if you're skilled enough that you've pushed those details into unconscious muscle memory, they don't matter anyway. And a language like C++ gives you the option of dropping down to the bare metal if the need arises.

There are a fair number of Lispisms in early Google code - MapReduce is the obvious one, and there're others that I'm not at liberty to discuss. However, they're Lispisms implemented in C++, where the author took the concept and transplanted them into a language that could give the efficiency needed. This is not a bad strategy - when you understand the concept fully, you're free to tweak it and adapt it exactly as necessary for your problem.

Perhaps not coincidentally, many early Googlers were also programming language & compiler guys before Google. Urs Hoezle (employee #9 and Google's first VP) had previously done StrongTalk (statically-typed SmallTalk), Self (the prototypical prototype-based language and an early inspiration for JavaScript), and the VM that later became Java HotSpot. Jeff Dean got his Ph.D on the Cecil/Vortex compiler, one of the first optimized implementations of CLOS-like multimethods. Rob Pike worked on Plan9 at Bell Labs and invented the Limbo programming language as part of it.

I think I half-agree with you. I don't think a great library can ever elevate an OK language to great. However, a poor library can certainly drag an OK language down to poor.

One of the most complicated decisions in developing any new programming language today must surely be where to draw the line separating standard library facilities from those to be provided externally. Provide too little, and you get a zillion incompatible external implementations popping up (C++ and strings; JavaScript and DOM manipulations). On the other hand, go too far, and you get your entire community relying on mediocre facilities, or worse, multiple competing facilities in your own standard (Java and GUIs; D in general). Likewise, if you have a common repository for additional libraries, you can be too restrictive on contributions and wind up with many basics still not covered (C++ and Boost) or you can be too open and wind up with a whole load of substandard or incomplete junk (Perl and CPAN).

I think that ease to create libraries is the key here.

I should point that the existence of specific libraries can be seen as a library creation with zero effort. So heavy-library-weight Java can be seen as a very productive language, but only when you use already created libs.

The difference between languages shows when you're on your own, when there's no library or tool under your hand. When you cannot find a giant to stand on his shoulders.

If we consider libraries part of the language, then I would say yes. All lisp implementations lack something for someone. And a language with great libraries may appear to be higher than others in some perspective because they offer a set of great existing tools. As far as limiting your thinking, Lisp in itself does no such thing, the libraries do it.

As a thought, I have sometimes wondered, why is it difficult for me to do something in Racket? It is not because a library is missing (though it could happen), but because it does not limit me. So it does not guide my thinking as much as let's say a strict language like Java.

When I don't have to think about classes with single inheritance and single-dispatch methods, I start to think about class systems, generic methods, multiple dispatch, may ditch classes altogether, go to a great unified graph of data or something crazier. I end up thinking how I should be modeling something and not doing the modeling itself. It does go overboard sometimes :)

Does anybody else face this problem?

I guess I'm not mad enough yet :-)

I made a list a while ago but it's a couple years out of date. It's probably a big underestimate because I last updated it before Clojure started to boom. I'll add anything people mention in this thread and if anyone knows more, email peter @ pchristensen . com

http://www.pchristensen.com/blog/lisp-companies/

Yep, I just been to the new lisp meeting in Zürich. The meeting was by a startup that do pretty cool networking stuff. The use like 80% lisp, some low level C code and a tiny bit of R.

http://teclo.net/

There's a ton. I'm working at a new company and we use JazzScheme for everything, but it's a spin-off and not a startup.

The author of the original post made an angel investment in a Common Lisp-based startup after they went through YC.

ITA uses Lisp and was bought by Google for $700M.

The startup that Akamai bought that helps companies make mobile versions of their websites primarily used Clojure, and continues to do so at Akamai.

My creation, the world's best photo sharing site, primarily uses Kawa Scheme: http://ourdoings.com/

Flightcaster was using clojure as a core part of their infrastructure.

PG's Viaweb: http://en.wikipedia.org/wiki/Viaweb ...and they managed a good exit ;-)

PG's take on this subject: it's about beating the averages: http://www.paulgraham.com/avg.html

Does it have to be a _startup_?

When I read his comment I automatically converted it in my mind to "Common Lisp has stood still for the past 25 years." 25 years is probably too much, but compared to clojure and racket Common Lisp seems archaic, like reading Shakespeare. If it has had updates they've been on the edges, making the standards bulkier and more arcane, harder to parse.

I laughed at your comment and there's a good point in there, but then I downvoted it because it's counterproductive to this discussion. I'll get a headache if the comments here end up like every other language war on the Internet.