I was terrified a while ago in reading a comment qualifing the interpreted dynamically typed
languages as an example of "modern programming", against the old compiled, static typed dinosaurs.
Nothing against dynamic interpreted languages, but a lot against ignoring the programming languages
history. The first widely used example of both categories (dynamically typed and statically typed
languages) are LISP and Fortran. Lisp born in 1958, and Fortran in 1957 (first compiler available).
When i started my career as professional LISP programmer, in 1984, the debate between dynamically
typed and statically typed languages was already twenty years old; there is no way one of the two
can be called modern, they are two side of the same coins, born together, will die together.
Today we live with the false impression that the computer world move very fast. A hip technology
today will obsolete in three years. If you take the time to study the computer world history, you
will discover that this is not true. While a technology can come up in fashion for a short period,
and then apparently fade away, the evolution of technologies, especially software technology, is
very slow, and their application take a long, some time very long, time. They disappear because for
a while they are not anymore in the economical sweet spot, but the acquire more sense later, and
reappear with new names and new syntactic sugar.
This is not to say that it is always the same stuff: the technologies evolve and improve at each
iteration, but radical revolutions or disrupting changes are very rare, and a lot more connected
with economics than with the technology taken by itself (as the Internet story shows).
Let's take some example in the software field, a few buff words.
Virtualisation: what a new concept; the first commercial system providing full virtualisation
on the server side was available in 1968, and it is still in production (it is called today Z/VM);
the advantages of using virtualisation are knew since that time, and the basic principles too.
Object Oriented Programming Languages: the first language with OO extensions was Simula, in 1967.
In the 70s we had already large scale OO systems, for example full OS and window systems completely
written in an OO language (thing that we still don't have today). Java have little or no innovation
in the language department: it is a very nice piece of engineering work, defining an OO language
simple enough to be widely adopted, still elegant and complete. But essentially, Java borrowed concepts
from existing languages, cleaning them up and providing (later 
an industrial grade implementation.
Graphic IDEs: actually came with OO systems, around 75. Industrially available at the beginning of
the 80s. You would be surprised to see how many similarities you could find between the Symbolics
Genera environment and Eclispe. But you still cannot recompile a single C function or Java method
and reload it on a running system, you could at the time (for C and OO Lisp).
Aspect Oriented Programming: changed name, but the MIT Lisp machine supported aspect oriented
programming (using technologies called multiple inheritance and method combination at the time)
and largely used it in its software architecture (colors where added to the window system
essentially by adding a color aspect to basic graphic objects, for example).
And so on ... these are just examples.
So, what all this summ up to ? Just wild rantings from an old developer ? No, all this is actually
about you, and what history (computer science history) can teach you.
Remember: almost no idea is as new as it seems. Even Html and the web. If are looking for something
innovative on a particular field, take a took back in time: you surely find ideas and inspiration
for you innovation. If somebody is trying to sell you the better innovation after toasters, check
it twice: you'll find that the innovation is very close to something already done.
My bet on the short term future is that we will see the development of a lot a new, innovating,
revolutionary programming languages dramatically simplifying concurrent programming (after all, we
*have* to use all these cores). Most of them will be re-editions of the studies done in the
beginning of the 80s, where the first hype wave around parallel architectures exploded.
Be ready to new renamed versions of CSP, Occam, Erlan, Actor languages and the others. And soon we
will talk about "modern" parallel programming, and how it make obsolete old languages as Java.