http://www.winestockwebdesign.com/Essays/Lisp_Curse.html
However I wouldn't call it "curse" but merely the truth that Lisp programmers need a lot of self discipline to write maintainable code.
Lisp was one of the first languages I learned at university (also Pascal and Ada). Afterwards I learned almost every other new programming language. Lisp and the Scheme dialects are still the most powerful languages of all, to this day.
People who are intimidated by such a raw power should take a look at Nim (nim-lang.org). It takes the best of several modern languages and it also has an amazingly convenient and powerful macro system. For instance:
template repeat * (body: stmt): stmt {.immediate.} =
block:
while (true):
body
template until * (cond: expr): stmt {.immediate.} =
block:
if cond:
break
var i=0
repeat:
echo i
i += 1
until i==7(The "basically" caveat above is because some Lisps honor this code-is-a-list principle more than others. E.g., I have seen remarks about how modern Schemes have moved away from it at least a little bit, with syntax which is importantly not quite a list, though I don't know any of the details. And CL has other kinds of reader magic --- like one-character "reader macros" and like the implicit package which is used as a default for symbols at read time when no explicit package is given --- that can in principle complicate the obvious 1-1 correspondence between source and parsed-as-list representation, although in practice that magic is very seldom used in such a way that you need to think about it.)
That's not exactly true. There are many languages, both old and new, which provide macro systems comparable to defmacro and/or syntax-rules. Dylan, Nimrod, Julia and Elixir come to mind.
I personally don't think there's one feature which makes lisps this great. It's really the whole experience, from syntax to repls to tools and so on.
A couple examples of some really great macros are those in PAIP[0]. In particular, look at the defrule macro[1][2] for a version of mycin[3]. The macro defrule is a DSL for creating rules about how to diagnose different bacteria. Also look at the rule macro[4][5] for defining DCGs[6], a way to parse natural language.
A great way to learn more about macros is through reading On Lisp[7], in which Paul Graham explores some of the really crazy things that are possible with macros, including implementing continuations[8], creating a DSL for ATNs[9] (another way to parse natural language), and even implementing an object system.
[0] http://norvig.com/paip.html
[1] http://norvig.com/paip/mycin-r.lisp
[2] http://norvig.com/paip/mycin.lisp
[3] http://en.wikipedia.org/wiki/Mycin
[4] http://norvig.com/paip/grammar.lisp
[5] http://norvig.com/paip/unifgram.lisp
[6] http://en.wikipedia.org/wiki/Definite_clause_grammar
[7] http://www.paulgraham.com/onlisp.html
[8] http://en.wikipedia.org/wiki/Continuation
[9] http://en.wikipedia.org/wiki/Augmented_transition_network