One of the main reasons I don't even want to touch Clojure is because I don't want to be trying to figure out Java stacktraces when things go wrong.
But if you're already familiar with any of those, it'll be the same as what you're used too.
It's been a while since I last used Clojure, so I don't know if the situation has improved in the meantime.
(defn foo [a b]
(def a a)
(def b b)
(/ a b))
I even made myself an elisp function for inserting the '(def a a)' into the code https://github.com/Bost/corona_cases/blob/master/.dir-locals... (enjoy).
Moreover, this approach with defs allows you to inspect every function, even those macro generated. And if committed, such a "debug session" is persistent across every instance where the code is deployed, from any development machine, through all test and staging machines right into production. (So when combined with some remote REPL access... you see what I mean?)
Another thing is that I like when my code strongly express the notion of compositionality, i.e. when it looks something like this:
(comp
...
(partial map ...)
foo3
(partial reduce ...)
(fn [p] (def s3 p) p)
(partial map ...)
(fn [p] (def s2 p) p)
(partial apply ...)
(partial map ...)
foo2
(fn [p] (def s1 p) p)
foo1
(partial apply ...)
(partial map ...))
informal coffee break answer: abstracted layers of abstracted abstraction within parametrized abstractions just don't feel right to lispers.
My browser is cpp program. Say, 10 layers are typical. Then, there's a libc + ui linux code. Usually in c, so even less layers. Say, 10 more. Then, there are sycalls annoying the kernel from time to time. Pretty shallow, btw, 5.
That's 30 roughly speaking. Maybe 40.
Java + clojure combo is not impressed, not at all.