EDIT: okay, I got downvoted for some reason. Care to explain why?
The mantra in Clojure is "don't write macros until you NEED macros" (or some alternative[1]). They make things horribly complicated and are awful to debug and make code that uses them hard to debug too... especially within a JVM environment (your code gets translated twice).
[1] http://clojurefun.wordpress.com/2013/01/09/when-do-you-need-...
Yes, but we're in a thread dedicated to Clojure ;)
> "Macros make things horribly complicated" is nonsense, or no skilled programmer would use them.
Which is what happens, really, and when used it's in a very limited fashion. For example, for quite popular projects inside the Clojure community: Leiningen used one macro[1] and Compojure two[2].
A properly done (and properly used) macro might not make things complicated, but this leads me to the next paragraph.
> ease of debugging is an issue quite apart from anything to do with macros.
It's usually hard, but macros make it HORRIBLE since you can easily lost track of the generated code. Like if translating from Clojure to Java Stack Traces wasn't hard enough...
Whenever you use a macro, the stack traces you receive from the code using it might not like like what you expect at all. Macros are bad because they mutate your code. You usually have to expand the macro and debug there instead of just looking at your damn code.
The big problem is not macros, but code which uses macros.
[1] https://github.com/technomancy/leiningen/search?q=defmacro&r... [2]https://github.com/weavejester/compojure/search?q=defmacro&r...
Also, these comments seem odd:
A properly done (and properly used) macro
The big problem is not macros, but code which uses macros.
The macros I know are effectively impossible to misuse. They tell you how they're supposed to be used and you just do it. There's not a lot of room to go wrong! Can you give an example of a macro which is hard to use properly?
I do that using functions :)
To put an analogy: people would've disgusted if you used a life jacket for no good reason, but they're handy when you really need them :)
I also like Lisp syntax regardless of macros, mainly because it's simple, consistent and prefix notation is really handy. The S-expr abstraction IS useful when dealing with code blocks (see https://news.ycombinator.com/item?id=5940620)