In many ways, Clojure seems like a deliberate response to each of the common complaints against Lisp.
Lisp is old and moldy. It must be primitive by today's standards.
The exciting languages to learn now are Python, Ruby, Groovy, etc.
Lisp is only for artificial intelligence.
Lisp is interpreted and slow.
Lisp programs page heavily, so they're even slower.
The parentheses look weird and hard to manage.
Lisp uses prefix notation for things that every other popular language
does with infix notation, which is just very weird. (And it leads to
more parentheses.)
Lisp is too big.
Lisp is too hard to learn.
Lisp is all about lists and recursion; that's all you do with it.
I don't know which implementation to use.
It isn't "batteries included" (that is, it's not easy to get set up with all the tools and libraries you need).
I don't like Emacs, and you can't use Lisp without Emacs.
Lisp isn't useful for my career; few potential employers want it.
Even the clojure contrib jar is not included by default and has to be downloaded separately and then clojure needs to be launched with extra command line arguments to setup the classpath properly (or you need to fiddle with the classpath from within clojure), the same goes for any Java library that you want to use.
Even by itself, that is better than most Lisps out there, if not enough to make a Pythonista happy. The problem with this stuff is usually the painful verbosity of Java necessary to use it, but you can wrap away that pain very quickly with Clojure.
I do take the point about needing to fiddle with the classpath for any other Java code you want to use. But for me the Java classpath system holds up better than most other software deployment mechanisms. Usually, you just download a jar file, drop it on your classpath, and it just works. I think jar files are an unappreciated success story of the Java ecosystem. Clojure has functions to easily add jars to the classpath at runtime, which is even better, but I find it does not always work seamlessly for me.
The only response that wasn't along those lines (or the old "Lisp is just too awesome for lame modern coders" shtick) was Ian Eslick's long one "A Coherent Portal into the Lisp World"; he actually seemed aware of why it was hard for new folks to get into Lisp and had suggestions about direction.
I'm getting ready to start a new project with a significant GUI forms component. I wanted to go with Clojure, but it still seems a little rough around the edges. So I'm leaning towards Visualworks Smalltalk, in part because it seems like a great language to prototype in and partly because the OOP aspect fits so well with GUIs.
I'm curious: did you consider Clojure? Would you mind elaborating on why you went with Smalltalk? given the number of Lispers on this site, the answer might be of broad interest.
Doesn't VW have a "pay us x % of your revenue forever" license (http://www.cincomsmalltalk.com/userblogs/cincom/blogView?con...)?
I am curious as to why any startup would want to accept these terms.
My app will work best as a thick client, but I still need a website to sell it.
I've been a Lisp hacker for years -- Symbolics Lisp Machine in my bedroom, coded in at least a half dozen different Lisp dialects -- but I ended up using Smalltalk for my startup. Treating Lisp's "rehabilitation" as a mere branding exercise shows just how screwed the Lisp community still is, and is symptomatic of the underlying issue. (By "Lisp", I mostly refer to Common Lisp.)
Lisp's problem is a meta-problem. The community is actively resistant to advancement, change, and evolution in the language. Attempts to modify (or even clarify) aspects of the Common Lisp standard are tedious exercises in futility, but the standardisation straitjacket is still seen as a good thing. A bit strangely, this resistance to change existing standards is accompanied by a slowness to standardise (even informally) anything that isn't already. The end result is that there's still no reliably portable way to write networking code in CL.
And this is why Lisp is unpopular.
The stasis is sad and ironic, given Lisp's hackerdom beginnings. Rather than wonder why, in 2009, so few are using Lisp, we should be amazed that the language is still pretty cool two decades after the innovation stopped.
I hope the Clojure guys change things. They seem to have the right approach.
Footnote: I was going to be a member of the CLRFI group (roughly equivalent to PEP or SRFI) that got some interest at ILC 2005, and which was going to try to create some sort of forward momentum in the community. It frizzled out, of course, and now http://clrfi.alu.org/ appears to redirect to the ALU homepage.