I don't think we should lose sight of the fact that extreme enthusiasm about functional programming and Lisp taking over as the dominant paradigm in programming is almost as old as programming itself.
Scala is explicitly marketed as a hybrid OOP/functional language. At least from "Programming in Scala," it seems as though writing idiomatic Scala really requires both paradigms. I see Scala as adding functional programming rather than de-emphasizing OOP, the former being a common thread in new (multi-paradigm) languages.
Take clojure for instance. Initially it had multimethods, which is a really useful and general facility. I like it. But now they're adding that dispatch-on-first-parameter special case back in.
Similarly, Go has omitted most of OO, but they use interfaces to support that same special case.
See this short video about protocols (and a little generic method and defrecord stuff): http://vimeo.com/11236603 (you should look at it even if you don't like clojure, it has some interesting stuff in it about the expression problem, and how to solve it in there)
This article is four years old, but since the prediction spans decades, I think it's fair to pick on it a little.
The OOP trend seems to be waning. The languages people are getting excited about lately seem to be de-emphasizing OOP and providing other mechanisms for some of the useful attributes of OOP.
Haskell and Clojure don't have OOP as most people know them, but Clojure's multimethods and Haskell's typeclasses replace OO polymorphism to a large degree. Scala and F# have OOP, but using it is optional.
Ten years ago, a new language intended for practical work and lacking OO wouldn't be taken seriously. That has changed, and the change seems to be accelerating.