I think many languages are realizing that syntactic abstraction is important and thus move toward lisp. I think many languages are realizing that HOF are important and are moving toward lambda calculus (which is simultaneously motion toward lisp). I think languages are learning that modules and the abstraction embedded in them is important and thus are moving toward ML (slowly). I think languages are learning that concurrency via isolated actors is a pretty good way to manage state in a concurrent system and thus are moving toward CSP (which is simultaneous motion toward lisp). Even more on that last point they might be realizing that process trees are a great way to make stable concurrent systems and thus are moving toward OTP.

Clojure is arguably a better language for being less pure as a Lisp. Many old school Lispers object to the dedicated vector and map syntax, but it's 2014 and these data structures are important and common enough to warrant shorthand.

Syntax is a trade between regularity and expressiveness. What you're seeing with "languages improving towards Lisp" is, in my opinion, languages seeking the benefits of greater regularity.

Old school Lispers don't object to vector or map syntax. Actually CL has vector syntax #(v e c t o r) and easily can add other data type syntax - that's why reader macros exist.

I don't know. Syntax is... hard to judge, but there's certainly some momentum behind the idea of a more rigid syntax (e.g. python significant whitespace, go shipping with formatting tools) that belongs more to the Fortran tradition than the Lisp one. OO style seems to be coming out of the other end of the hype cycle, and while many argue that OO is a lispy concept I don't think the community ever really got behind it. Metaprogramming is still an open field, but I see as much going on with languages that make a strict delineation between compile and runtime as with the looser lisp approach.