Which one of the following new lisp implementations is more likely to gain the momentum and more mainstream acceptance, arc by Paul Graham or clojure by Rich hickey?
They both launched at the same time, but seems there is more community interest in clojure so far, from both lisp and java folks.
I'd say Clojure, mostly because of the Java VM backend, library access, etc. Arc will have a very hard time getting to a state where it has access to a similar set of utilities and stability.
(@joking: Feels like BETA v. VHS all over again...)
Clojure will certainly be more usable in the short run. Because it runs on the JVM, it can be used with existing Java codebases, and it can make use of the libraries that already exist for Java.
However, Paul Graham's goal is to make a "100 year language". He created the language and built some applications on top of it. He then looked through the source code of those applications to see how the code could be shortened, and how common patterns could be made easier and more succinct. Eventually he released the code so that other people could use, test, and offer feedback about it.
So if your question is, "Within the next 5 years, which language will I be more able to use to deploy code within a large company" then the answer is certainly Clojure.
If your question is, "20-100 years from now, which language will be more widely used and/or have been more influential on the evolution of the Lisp family of languages" I'd bet strongly on Arc.
Clojure already has momentum, and could very easily steal Arc's user base away since it's already possible to get a high level of productivity due to various things like the way all of the collection types can interact, having the entire java library set available to it, etc. I just don't see Arc catching up after such a weak start.
Note while I haven't had much time to use either yet, I admit to being a bit of a Clojure fanboy atm, as everything about the language appeals to me (though I admit I sort of wish it was on the .NET platform over the JVM, but hey...)
As to which will be "more mainstream" than perhaps the other, I don't know. As to "mainstream" in terms of something like the Ruby's and Pythons of the world, neither will make it "mainstream".
Clojure's leveraging of the JVM and its concurrent programming constructs are both nice features of the language, but in the end, Clojure is a Lisp, and that implicitly will kill it from being "mainstream".
There are a lot of fine Lisps out there, and there have been for a long time. A LONG time. They've been in the JVM, they're fast, they're capable, they're powerful, they're AVAILABLE, and they're small niches implementing nichey things by folks who like to do nichey stuff.
Yes, we've all heard of the random Great Lisp Success stories. But they're rare and far between, and most definitely not mainstream.
Here's the thing, the platform and runtime of Lisp is not what's "holding it back". Libraries, runtime, free, not free, etc. It has been long enough that all of those issue could have been solved -- and they weren't. The opportunity has been there, and either nobody is taking advantage of it, or nobody cares. Remember, the Magnum Opus of the lisp Community, the cry from the dark to oppressed programers everywhere, Grahams book, "On Lisp" (excellent book, btw, and now free), came out FIFTEEN YEARS AGO. I know, I bought it back then.
In this time, we've seen the rise of several other dynamic languages that have become mainstream: Python, Ruby, and, of course, the king of all modern dynamic language, JavaScript. All of these share a key concept relevant to this discussion: they're NOT Lisps. Sure, deep down, they're very "Lispy", they're runtimes are very similar in many ways. But nobody thinks of them as a Lisp.
So, one of these implementation may be more popular than another, when measured against each other, but neither of them will ever hit "mainstream".
However, never let it being or not being mainstream stop you from using one of these systems for yourself. Clojure looks like a fine system.
Since no one else posted this, something I found interesting http://eli.thegreenplace.net/category/programming/lisp/sicp/
He posted his own experiements with SICP in a couple different languages (both schemes AND CL). Once you've done a problem seeing someone else's version never hurts.
To me there is no question that Clojure is the stronger language and will win out to Arc in the short as well as in the long run.
Putting aside the advantages Clojure has by running on top of the JVM, there are some very powerful and well thought through features that Arc doesn't have, like the "seq" abstraction (lists, arrays and dictionaries are all seqs, and all algorithm operating on seqs (like map, filter, ...) work on all of them), lazy seqs, software transactional memory as the basis for mutation, etc.
Arc as a language, on the other hand, has very little to offer that puts it ahead of other Lisps, most notably Common Lisp, other than a different syntax.