Bah, screw functional languages, I'm still waiting for relational languages such as Prolog to go mainstream.

Many of the reasons why OOP is falling out of fashion (at least in games/HPC) is because of it's ignorance of performance issues and difficulty to parallelise (extensions such as message passing systems / the actor model help with parallelism though)
See: Pitfalls of OOP

However, as shown in the above source, this isn't a death-blow to OOP, as the issues can be overcome. What we're going to is is the internals of OOP systems be completely reinvented over the next 10 years.

Same goes for functional programming languages, actually -- their internals will be re-written over the next decade to work even better on multi-core / NUMA computers.

I don't think that even makes sense anymore. Computer architecture? Isn't the compiler responsible for most of that work nowdays?

If you've written code that assumes that there's one CPU and one big bank of virtual RAM, then, there's no way that a compiler can magically make your code work on a machine where there's one CPU with a large bank of ram, with serveral co-CPUs each with their own private RAM.
i.e. architectural changes on the scale of NUMA require re-architecting of your code, not just recompiling with a new compiler.


blabla, paradigms are here to bring ease to us. Not to get us into the "god knows what" of electronic's whatsoever.

Why would the other fade away and other become big? Why can't functional and OOP coexist? Scala has both ways and it's awesome. Also functional programming doesn't take the hard part out of parallelizing. If you don't know how to make thread safe code in OOP then I doubt you could make it as a functional programmer(or you need to study more ). Threading issues come from accessing shared resources and operations that are dependent on each other. Functinal programming doesn't magically solve those.

The thing with pure functions (which is the only thing you're allowed to use in a pure functional language) is that there are no side effects, pure functions can always be executed in parallell unless they explicitly depend on eachother, in a pure functional language there is no such thing as shared resources or state and function interdependance is limited to the return values of the functions which makes it trivial for the VM/Compiler to parallelize the software automatically.

It doesn't magically solve the problem, it just rips away the tools used to create the problem and forces the programmer to do things differently. (This is why pure functional languages are "hard" to use)
(Most mainstream functional languages aren't pure though and does provide tools that allow the programmer to write imperative code)

Many modern c++ compilers allow you to mark functions as pure which allows the compiler to perform far more optimizations on them (__attribute__ ((pure)); for g++)

Nope, OOP is not going down, it has too much momentum. It will just be supplemented with other programming models.