Lisp: More is less

On the contrary, beauty of Lisp comes from being accidentally discovered minimal set of unique interweaving features (very few special forms, high order procedures, list structure, to glue code and data together, macros, the way to use Lisp as a meta-language to itself, type-tagging of values, instead of declaring variables, and, the numeric tower, and lexical scooping, as recent addirion).

This set of features is very balanced and good-enough. Adding more "foreign" features actually ruins the balance.

Having "just this" and following the paradigm of layered DSLs embedded in a Lisp, popularized by SICP, lots of complicated things could be created, including CLOS which is nothing but a DSL (a bunch of macros and procedures).

This notion of what a Lisp is actually helpful to understand not just Clojure but also Haskell, which is, in some sense, also a small kernel based on Lambda Calculus and tons of syntactic sugar.

By adding more and more features without breaking the balance we got Common Lisp, while an attempt to keep the balance produced R5RS.

If we switch the perspective on what Clojure is to the notion of a scripting language for the JVM (a-la Ruby) with sometimes looks like a Lisp and sometimes behaves like a Lisp, but strictly speaking not a Lisp, because the unique balance was ruined by adding stuff, everything, it seems, falls into its places.

Arc is a dialect of Lisp, Clojure is language of its own, but marketed as a "modern dialect of Lisp", which makes no sense.

Manager types barely tolerate literate programmers, let alone someone who can make something that a mouth breathing moron can't understand.

Less what? Do be more precise. I've heard that with regards to complexity – not so much with regards to power.

Macros is the way to add new special forms to a Lisp or a DSL embedded in it. This is why macros are there.

To avoud macros is to restrict oneself from designing a program as layers upon layers of DSLs which is the most powerful paradigm. Just look at that Rtml DSL of ViaWeb system.

I don't think the author understands that these things happen at different times. Especially because they said "at runtime" when macros expand much before that.

On the contrary, something like Rails is what I'd call extending the language arbitrarily at runtime. So the very lack of macros is what motivates shaky transformations at runtime.