A lot of these are personal preference and borderline traditionalist, and as pointed out by others, the dynamic binding one is in fact not strictly true.<p>One thing that <i>does</i> however bother me about Clojure is the interaction of dynamic binding and lazy evaluation. Allow me to illustrate:<p><pre><code> => (def *test* 0)
#'user/*test*
=> (binding [*test* 2]
(map #(* % *test*) '(1 2 3)))
(0 0 0)
</code></pre>
The call to <i>map</i> is lazy, and the returned seq is only evaluated once it hits the 'P' of REPL, which is outside the dynamic binding of <i>test</i>. If you surround the <i>map</i> call with <i>(doall</i> and <i>)</i>, the result is (2 4 6).<p>This is of course a trivial case, but I've been bitten by this in practice where the binding, lazy sequence and var evaluation were a few call steps apart, and it's always been very unpleasant. Most of the time, it's involved vars which don't have a root binding, so it throws an error, but in other cases it's a lot more serious.<p>I guess the same problem can be provoked in both Clojure and CL by returning a closure evaluating that var to back outside the dynamic binding, but since you'd be explicitly invoking the closure, it's a lot more obvious what's going to happen than the "magic" that is lazy evaluation.
I was interested in Clojure before, but the critisism I found in the two recent posts here on HN make it even more interesting. I feared something substantial might turn up that really defies using it, but to the contrary: if issues listed in the blog posts are the biggest problems people find with Clojure, then that is quite promising.
I don't have much experience in CL, but I started to really like the fact that clojure is Lisp 1. When I have a hash map "client", I can use all three:<p>(get client :phone)<p>(:phone client)<p>(client :phone)<p>It takes some getting used to, but I already came to expect (and enjoy) that any symbol I use can be a function.
On #5, the code isn't doing what the author may think:<p><pre><code> (let [#^int a 2
#^int b 3]
(cons a b))
</code></pre>
<i>a</i> and <i>b</i> are not hinted to be primitive types. Type hinting is purely for objects. Use hinting to make it clear to the compiler what sort of <i>objects</i> you are passing into something (e.g. a constructor that takes a String). If there is confusion, clojure will do reflection.<p>The right thing to do in this case, is the second thing that the author mentions:<p><pre><code> (let [a (int 2)
b (int 3)]
(cons a b))
</code></pre>
a way to see that <i>a</i> and <i>b</i> are really primitive is:<p><pre><code> (let [x (int 5)]
(.shortValue #^Integer x)) ; exception: "can't type hint primitive..."
</code></pre>
There's a post on the mailing list that goes over this much better than I did (and where I drew the examples): <a href="http://groups.google.com/group/clojure/browse_thread/thread/b0554f7381b8db96/74bf85fabc12761a" rel="nofollow">http://groups.google.com/group/clojure/browse_thread/thread/...</a><p>I understand that this is really beside the point, that the author finds type hinting syntax unattractive, but I just wanted to clear up confusion (if there was any).<p>EDIT: clarity
I'm not familiar with CL's "PROGV", but you can indeed dynamically rebind vars at runtime with Clojure:
<a href="http://paste.lisp.org/display/73551" rel="nofollow">http://paste.lisp.org/display/73551</a>