For example, Python has a REPL but it is not very well suited for interactive programming. For example Python does not handle you redefining a module after you import it without some voodoo. Nor it has forward references. For example in Lisp I can define a method that especialices on a class I haven't yet defined. Or define a function that calls function B which I will define later in the code. Nor have I seen something akin the slime Inspector and presentations, which are not quite there as the Symbolics Genera environment for interactive programming
> Multiple inheritance – I think this is coming to Java finally
But it's been in C++ for a very long time.
> Functional programming techniques (map, reduce, etc.) – Still ahead
Still ahead of who? Haskell? How so?
Take Java 8 which now has map: sure, you can pass a lambda expression with a custom function body, but is using functions (particularly side-effect-free ones) as arguments idiomatic otherwise? I can only imagine the amount of ceremony code that ensues when trying to merge those worlds. Don't get me wrong, having map/reduce/etc. is an improvement to Java for sure, but Lisp is still well ahead on the overall cohesion and utility of such things within the context of the rest of the language.
1) Turing-complete is a bug, not a feature.
2) C++ template metaprogramming has been Turing Complete for ages.
3) There are nonetheless significant limitations on what you can do with templates in C++, compared to what you can do with macros in Lisp.
"Turing Complete" is a theoretical construct that doesn't really mean much other than giving you easy ways to prove that certain questions about the system can't always be answered. One significant reason for this is that "Turing Complete" merely means that you can embed any computation in the system in some encoding - with something like a macro system, the encoding you generate is the whole point.
To my mind, having eval available is a cheap way to make sure you are sufficiently powerful. In principle, it's not the best way. In practice, it's arguably the best way out of options at hand, though some alternatives compete.
The two are equivalent (provided that the target language that can be evaluated is itself turing complete) -- that's rather the nature of turing completeness. If you have the former, you can make the latter with it and nothing else; if you have the latter, you necessarily also have the former.
Lambda expressions - just now reaching Java and C++, been in Lisp forever
Garbage collection – (obviously)
Turing-complete (edit: fully evaluating) macro systems – I've heard C++ is moving in this direction (not sure to be honest) but Lisp is still ahead on this
Gradual/optional typing – Others have been moving towards this, CL has had it forever
Interactivity/REPL – e.g. Swift may finally give a REPL to systems programmers, Lisp has had it forever
Dynamism/late-binding – Lisp is still way ahead on this, goes hand-in-hand with interactivity
Everything serializable – Lisp is still ahead
Structured code editing (paredit) – Lisp is still ahead, not sure anyone else even knows what this is
Multiple inheritance – I think this is coming to Java finally
Image systems (hibernating a running process) – Still ahead
Condition system / advanced exception handling – Still ahead
Functional programming techniques (map, reduce, etc.) – Still ahead
Keyword arguments – Recently added to Ruby, Lisp has had them forever