"We were not out to win over the Lisp
programmers; we were after the C++
programmers. We managed to drag a lot of them
about halfway to Lisp."<p>- Guy Steele, Java spec co-author<p>Steele seemed to be trying to encourage those who saw the glass as half empty to see it as being half full. The article makes some valid points but surely, from a high level, clojure can only be seen as a glass that's very nearly full.
A quick analysis of the article from the point of view of an ordinary Clojure programmer:
1) Yes, it's tied to the JVM (or JS). This is a huge trade-off and not without its costs, but it's one Clojure programmers are happy to make.
2) You can't do reader macros: true, Rich Hickey dislikes them because of the nasty effects they have on re-use. However, Clojure now has reader literals which fill in _some_ of this gap. Again, a trade-off.
3) He doesn't like [] and {}. I don't really understand why: paredit copes perfectly well with them. I never actually need to parse ))]))}) in my head.
4) Over-reliance on recursion. Possibly true, but a decent generator macro would probably address his issue. (And we're quite close to having one.) Bear in mind you _can_ have mutable private state in Clojure, it's just rarely used.
5) Lazy sequences complect sequences and streams: true. Lazy sequences are not, in fact, perfect for all use cases. That's why reducers and async got introduced.
6) It doesn't feel like a LISP: if that means it doesn't feel like elisp, you're not going to catch me crying.
7) It didn't have a killer app: now it has several.<p>Overall, many of the criticisms are valid, but
a) some are design decisions with practical trade-offs*
b) some have been addressed since the article was written<p>*I mean seriously, using the JVM is a huge negative in certain ways, but does anyone believe Clojure could have got off the ground if it didn't? Rich Hickey tried other approaches for years before this one worked.
Of course, since the article was written, we've had Storm, Riemann and Cascalog. That's 3 killer apps on the platform. I don't think Clojure is going away anytime soon.
"Rich argues, that defining both lists and vectors with parens (in Lisp list is '() and vector is #()) is complecting."<p>Really? That strikes me as, well, kind of absurd.<p>The author of the linked post complains about the use of exceptions over conditions, but you can define conditions using dynamic scope anyway: <a href="https://github.com/bwo/conditions" rel="nofollow">https://github.com/bwo/conditions</a>
I wonder, where does Scheme fall in on this whole, uhm, scheme?
Especially w.r.t. this part:<p>"[Clojure] doesn't have facilities to control the reader in the same way CL does: actually, in this regard Clojure is very different from Lisp — it hardly provides facilities for controlling any aspect of the language — and this control is a critical part of Lisp's DNA"<p>Or, is Scheme as good for stratified design as CL?