Type systems are the one exception, but it still remains broadly true that Lisp was way ahead of everybody. There are many things we could talk about besides type systems:
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
I don't know about Swift but equating a REPL to interactivity is a horrible disservice to Lisp (and Smalltalk).
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
Excellent point. I found myself struggling to describe Lisp in terms that non-Lispers would understand (blub paradox I guess), and I figured almost everyone knows what a REPL is. You're absolutely right that a REPL itself is just scratching the surface, and there is all kinds of interactivity beyond that.
Still ahead of mainstream programming languages, which are typically imperative by design, and usually overly "noun" focused compared to the "verb"-friendly nature of Lisp. Adding map/reduce/etc. to the noun languages is a bolt-on that is not exactly ideal.
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.
Multiple inheritance is much more complicated and restricted in C++ than in Common Lisp. As with many things in C++, you really have to know what you're doing to use it correctly. In CLOS it pretty much just does what you expect, and only when you want to do something unusual do you have to learn the finer points.
"Turing-complete macro system - I've heard C++ is moving in this direction (not sure to be honest) but Lisp is still ahead on this"
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.
I understand what you're saying. What I mean is not the trivial "nand is turing complete" sense, which I agree is harmful and silly, but full eval capabilities. Lisp macros can fully evaluate Lisp code, and I consider this a great feature, but I don't know how else to describe them. "Full evaluation macros"?
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.
> What I mean is not the trivial "nand is turing complete" sense, which I agree is harmful and silly, but full eval capabilities.
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.
Yes, it was a poor choice of terms. To be clear, eval isn't equivalent except within the narrow theoretical notion of turing completeness: it can do I/O, for instance file I/O. And it accepts high-level language code directly which is very important in a practical sense compared to, say, accepting nand instructions only.
It's hard to describe because even "full access to the language at compile time" would be useless if that language were C++. The advantage of macros is that you have access specifically to Lisp at compile time, not just any old blub language. And that just circles back to "Lisp is great". :)
Newer features tend to use type systems for part of their implementation because they're a powerful tool, but I feel the feature is its own thing. I'm excited about typeclasses, or anything else that solves the same problem. I'm excited about effect systems, which tend to be implemented as types but don't have to be. I hope to learn more about the matryoshka approach, which seems like the opposite thing or at least opposite emphasis to lisp's approach to metaprogramming (which emphasises doing the metaprogramming in the same language as the program itself).
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