No, concurrency is also supported by free CL implementations - like CCL.
But the fact is that despite its lack of mature tools, Clojure is more newbie-friendly than CL. That should give CL advocates pause.
As for running on Java, yeah, that's part of what it (currently) is. It's a strength and a weakness at the same time.
Once Clojure becomes self-compiling, we might see that change. I'm actually working on a toy Clojure->LLVM compiler for my own education. There are enough people who love Clojure but have a distaste for Java that I expect we'll see a native version of Clojure in the next few years.
What does it make Newbie friendly? I was just seeing a video of Robert C Martin explaining Clojure - he looks like a Lisp newbie to me. Half of the time he was spending in a primitive REPL in a Terminal. Is that Newbie friendly? Maybe because one does not get distracted with slightly better REPLs, a SLIME REPL or even one of the other advanced REPLs? Then he was using Intellij. Is that more Newbie friendly? Perhaps to developers coming from Java?
I wonder how many of you are using Clojure like a Lisp (with its interactive development tools), and how many are using it like typical scripting language?
Anyway, I expect Clojure to improve on that front over time. But, as time goes by and the compiler is written in Clojure, the REPL gets improved, it has some better error handling, it gets real error messages, etc etc. ... it then will no longer be the sexy small Lisp which you have seen grow up. It will be a Lisp implementation like many others with all its complexity.
As a newbie, I have to disagree. Clojure has a ton of syntax to get used to, and to make it useful, you have to learn all the neat Java libraries on top of it. I found more resources and nice explanations for aspects of CL, and when I compare it against Clojure, I find I miss a lot of the nice functions and tools for CL.
Here is a fun newbie point on it: In the first hour of playing with CL, I learned how to debug it. Not so with Clojure. Trace? Step? Maybe I should be using harder-to-find online tutorials for Clojure?
Anyway, it boils down to opinion as to what is "easier". I was looking for something with batteries included that would compile to a distributable executable and be super flexible; CL fit the bill with the sbcl implementation. It successfully pulled me away from other fun languages, like Erlang.
http://common-lisp.net/project/armedbear/
I am in the middle of porting it to Android, but as is, you can use it to write anything non-mobile/embedded, and it can call Java libraries just as well as clojure.
This is very fuzzy terminology. What defines newbie-friendly? I can get an "enterprise-quality" Common Lisp environment and language for free. Likewise, the CL standard is also freely available and meticulously cross-indexed. As an added bonus there are countless Common Lisp books available on every imaginable topic. There are also numerous package managers (including the exciting http://quicklisp.org) at my disposal. And for the cherry on top there are luminaries like Ranier Joswig and Xach Beane willing to take their free time to answer my idiotic questions.
This, to me, is the very definition of newbie-friendly.
There are bordeaux-threads and portable-threads, and they mostly work, but I usually just fall-back on limiting my threading calls to a small number of functions and then manually adding #+ stuff to get it to work when I want to port to a new CL.
People really expect some form of threading/concurrency to be standardized across implementations.
The CL community has been occasionally successful in making new de-facto standards (Gray streams, ASDF, and to a lesser extent MOP), so there is hope.
And that's only in the commercial implementation.