It is written in SICP that programming is in fact building layers of abstraction, the lower one serving as a programming language for the higher one. Macros or not, everyone designs new 'programming languages', though today's term of art is "API".
If you have to read and understand 200 lines of code with no documentation, take it up with the incompetent developer.
This argument holds no water whatsoever. Bad programmers can cause all sorts of damage, why should everything be dialed down to their level?
Clojure forces you to deal with concurrency issues in a way that might be premature optimization at best, tremendous waste of time at worst. As opposed to DSLs in CL with reader macros, I have no choice in the matter, it's all or nothing. Yet I don't see you complaining.
Good DSLs (meaning they map very well to the problem domain ) are irreplaceable. They can make a problem completely disappear.
ROFL. You're adorable. :)
You're also conveniently ignoring the maintenance required on the DSL itself. DSLs are, themselves, code, and code must be tested, updated, will likely experience regressions, etc.
DSL compilers are the simplest and cleanest code possible. They're nothing but a chain of very trivial tree rewrites, and with a help of a proper DSL you can write and maintain them easily.
Forget JSON, the problems are evident even when using something like CL-INTERPOL, which makes minimal changes to the read-table.
It's pretty hard to hit the right balance between adhering to the original language and matching your DSL to the problem domain. If you build a DSL that requires a day of studying code and documentation in order to make a minor change, you might be better off without it.
This is a theory. Reality is a bit different. There is nothing in common between, say, JavaScript and the regular expressions DSL embedded into it, but yet they come ok together.
Code style is overrated.
Inventing your own alien syntax is a recipe for long-term code maintenance disaster. Anyone who's worked on a codebase that's lived longer than a decade has likely experienced this pain firsthand.
DSLs become more readable and closer to the way the problem domain experts think if they are using the more convenient syntax.