[1] https://news.ycombinator.com/item?id=7671549

For the rest of the family, there's a lot of mutual intelligibility. And, a metaphor is a metaphor, no metaphor holds if you dig deep enough.

> A Lisp developer looking at Clojure code will understand very very little.

This is an assumption, not a fact. Java interop code and (recur) are a bit confusing in the first sight, but not undecipherable.

The prog lang that's most like English is C++: too many things are overtly overloaded, see phrasal verbs.

I would guess that 10% of its operator names come from Lisp. Okay, that's a wild guess. Let's look at the special forms:

def-, if+, do-, let+, quote+, var-, fn-, loop-, recur-, throw-, try-, monitor-enter-, monitor-exit, ...

Around three from thirteen special forms have roughly the same name/meaning in Lisp.

Let's look at printing: pr-, prn-, print-, println-, newline-. None Lisp names, either they don't exist in Lisp under that name or they do something else. PR and PRN don't exist in Lisp. PRINT prints a newline before printing the object. PRINTLN does not exist in Lisp. NEWLINE is called TERPRI. Thus even for a simple thing as basic IO the API is different.

Any modern fiction. No chance.

Not German, Clojure. Clojure is pretty easy.

    user=> (list 1 2 3)
    (1 2 3)
    user=> (list? (list 1 2 3))
    true

    user=> (cons 0 (list 1 2 3))
    (0 1 2 3)
    user=> (list? (cons 0 (list 1 2 3)))
    false

    user=> (list? '(0 1 2 3))        
    true

WTF?

Compare ELISP:

    ELISP> (listp (list 1 2 3))
    t
    ELISP> (listp (cons 0 (list 1 2 3)))
    t

    CL-USER> (listp (list 1 2 3))
    T                                                                                                                                       
    CL-USER> (listp (cons 0 (list 1 2 3)))
    T

http://www.nongnu.org/txr