Computer science is constantly pushing forward. Not so long ago we had a huge shift in languages and features when OO came about. Recently functional programming has made an appearance. Is it set to change everything or is it a passing fad? If it is a passing fad what do you think is next?
EDIT: Thanks for the comments. Good point functional programming has been around for a long time. Sorry I have only recently started noticing it. Maybe there has been a resurgance.
People often say it's aspect-oriented programming. But of course, that's just one possible path :)
BTW, functional programming is rather "before" than "after" OO programming (historically speaking.. that doesn't mean OO is "better" than functional)
Functional programming has been around since the '50s, with LISP being one of the more well-known ones, but, it is becoming more popular. I believe the popularity is due to the fact that it is hard to write applications for multi-core systems, whereas for a functional language it would be simpler.
Pure OOP is probably going away as there are limitations on it that some other solutions help with, such as DI or AOP.
After carefully examining the arrangement of many, many chicken entrails... I think i can say with certainty that The Next Big thing will be...
The same as every other big thing: code that gets the job done without getting too tangled up in some abstraction.
Actually I think functional programming is a lot older then OOP.
Anyways, the future might be the model-driven engineering (MDE). Stuff like for example Executable UML.
Meanwhile, evolution of OOP is AOP (aspect-oriented programming).
Functional Programming is old school, I remember doing lots of Miranda back at University.
As for what's next... what will be will be. It's all about adapting.
Personally I think the next big thing will be parallel / threaded systems. Whilst this has also all been done, multiple cores and multiple processors are everywhere. Distributed systems across the internet are a reality, we need to make sure anything we code can utilise all of this without major refactoring.
I actually love this question! I work closely with a guy who has been in the industry since the 70's. Whenever I am talking about something "new" with him, his first question to me is "What did they call it 30 years ago?" When I answer that, he understands it immediately. :)
To be more responsive, Domain Specific Languages are an interesting trend. It remains to be seen in my mind if they gain mindshare and solid tool support.
Literate programming/Domain Specific Languages
It doesn't need to be "new" to become mainstream.
OO was long ago conceived but hardware was too slow to make it feasible.
One of the first objections for Java adoption was it was too slow ( and indeed it was ) but since better VM's have appeared and hardware is much faster now, creating a complete OO solution doesn't sound crazy anymore.
Literate programming is not new either, but every day since processing cost is cheaper a new layer of abstraction can be introduced into the software and create programs that are very specific to the domain where they are used.
The most successful/notorious example is Ruby on Rails, is not only a development framework, but actually a different language which, is well specific for webdevelopment domain.
Here's an interesting article in the subject.
Language Workbenches: The Killer-App for Domain Specific Languages? by Martin Fowler.
The central tenets of OO are messaging and hiding state and implementation behind interfaces. Lots of Java systems use imperative programming rather than OO - it's full of gets and sets and observers, so ends up programming by non-local side-effects (when the object's boozle property is set to true, set the parent object's flug property false). C# has a mix of OO, imperative (properties), and events.
So the thing that will happen after OO might be OO done right - messages of immutable values sent to channels where stateful transducers operate on them, no shared state at either small scale (to allow SMP to be tractable and scalable) or large scale (to allow distributed processing to be tractable), and having mostly immutable values helps the application of tools such as pi-calculus to analyse and reason about the system. IME transducers using traits and composition achieve better reuse than OO with inheritance.
Such a system could subsume OOP and SOA/ROA. You don't need AOP if you have the channels explicit, as most of the AOP implementations seem to be intercepting method calls, and anything which lets you specialise channels means you can intercept the messages on them using the same patterns as you do at a larger scale.