Amusingly, Martin also talks about the Language Holy Wars of the mid-1990s. Thankfully things have gotten better since then (at least in my circles). In terms of those wars, Martin says dynamic languages beat out static languages. But I'd say instead that multi-paradigm languages have beaten out single-paradigm languages. The last hangers-on like Java are now adding not only dynamic features, but they're also starting to incorporate parts of other paradigms (namely functional programming, e.g. Java generics for parametric polymorphism, anonymous and inner classes for closures). Heck, even C++ is planning to add lambdas and a knock off of Haskell's typeclasses. Whether or not imperative/OO code is on the way out, declarative/functional code is well on the way in.
My big thing is more about what is taken for the skeleton on which everything else is hung. For that, nothing can beat the pure functional paradigm in my world: a powerful type system, type inference, parametric polymorphism, referential transparency, algebraic data types, etc. These features are so basic and so pervasive that they really must be built in at the lowest layers. Type safety isn't something you can just turn on and off, otherwise there's no safety.
As far as OO goes, I think this OOPSLA debate (http://www.dreamsongs.com/Files/ObjectsHaveFailed.pdf) really says a lot. The OO model of the world has some major insoluble problems, so it can't be used as the core. And yet, OO as we understand it today really must devour everything in order to deliver on the promises of the paradigm. All experiments I'm aware of to combine it with functional programming without being dominant have all been named failures and relegated to obscurity: Common Lisp's objects, Ocaml's objects, O'Haskell. (Scala gives a more even split and hasn't been around long enough to fail yet; it'll be interesting to see if it takes off.)
Despite the failures of OO, there are certain problems for which interface inheritance and mixins do give much cleaner code than equivalent formulations in current functional languages. So there's certainly room for something like OO within the functional world. After making the changes necessary in order to get over the fundamental issues and the integration problems, I think this new thing won't look much like OO to the Java, Python, and Ruby crowds. I'd be interested to see it though.
no subject
My big thing is more about what is taken for the skeleton on which everything else is hung. For that, nothing can beat the pure functional paradigm in my world: a powerful type system, type inference, parametric polymorphism, referential transparency, algebraic data types, etc. These features are so basic and so pervasive that they really must be built in at the lowest layers. Type safety isn't something you can just turn on and off, otherwise there's no safety.
As far as OO goes, I think this OOPSLA debate (http://www.dreamsongs.com/Files/ObjectsHaveFailed.pdf) really says a lot. The OO model of the world has some major insoluble problems, so it can't be used as the core. And yet, OO as we understand it today really must devour everything in order to deliver on the promises of the paradigm. All experiments I'm aware of to combine it with functional programming without being dominant have all been named failures and relegated to obscurity: Common Lisp's objects, Ocaml's objects, O'Haskell. (Scala gives a more even split and hasn't been around long enough to fail yet; it'll be interesting to see if it takes off.)
Despite the failures of OO, there are certain problems for which interface inheritance and mixins do give much cleaner code than equivalent formulations in current functional languages. So there's certainly room for something like OO within the functional world. After making the changes necessary in order to get over the fundamental issues and the integration problems, I think this new thing won't look much like OO to the Java, Python, and Ruby crowds. I'd be interested to see it though.