The industry seems to be in one of its "Gee, I wonder what's next? What's the next Big Thing?" phases at the moment in the field of software development.
Why this should be happening now is an interesting question in itself. Let's spend a minute on that one before proceeding. It could simply be that the big guns of Cobol/Java/C++/C#/PHP/ASP/Perl/Python and so on have been around long enough for the industry to appear to be on some sort of stable plateau. If there is one thing that this restless industry is always bent on destroying, it is those nasty stable plateaux. The grass is always greener on the other side. Even if it isn't greener, it might be profitable so let's go there... (Apologies, cynicism crept in there for a moment!)
Another reason could be that market forces are driving developers to build certain types of systems that are proving too hard to build with existing tools. Some would argue that the new crop of CPUs emerging with multiple processors per core is forcing a significant re-think [1]. Others would argue that to get the best out of Agile Programming practices [2], you need to re-think your core tools.
Personally, I think it's a little simpler than that. Squint to the point where most of the extraneous detail is blurred and you will see that most new systems development is happening in one of three, largely stable foci: The Java ecosystem, the .NET ecosystem and the LAMP ecosystem. All three are very large, quite stable and readily compared one to the other. At a high enough management level, there is little reason to pick one over either of the other two. They all do the same job (essentially), all have readily available tools and developer communities. How to choose?
That, I think, is what is driving the "next big thing" noodlings. Competitive forces are at work to attempt to differentiate these offerings at a level your average developer can appreciate. Whichever one of these three stable "stacks" incubates the next big thing, will probably win big. It may completely win, striding ahead of the competition. Alternatively, it might just remove one of the other two contenders, resulting in bi-polar rather than tri-polar competitive environment for application development stacks.
Regardless of the reason for the search for the next big thing, it is certainly well under way. What will it be? What is the next big programming language? Will it be some sort of Java++ or maybe Ruby [3] or maybe Python [4]? Maybe Perl [5] will make a triumphant return on the wings of a parrot [6]? Hey, how about Erlang [7] or Fortress [8] or Haskell [9]?...
Interesting possibilities one and all. However, I suspect that the next big thing might be one of those quantum leaps that happen from time to time. A game changing leap. What if the next big programming language was not so much a language as a language for creating languages? Intellectually, this sounds appealing as it has the potential to make all the existing languages just special cases of a grander theory. Geeks like that sort of thing.
At a practical level however, outbreaks of this sort of thinking can be seen in the programming community, typically under the moniker of Domain Special Languages or DSLs [10]. Programming languages are again starting to sprout DSL capabilities. Ruby and Fortress - of the two languages already mentioned - are examples.
I think the time is right for this sort of thinking to become mainstream. The industry is at the point where the irrational exuberance surrounding using XML as a DSL for programming languages has passed (thank goodness!). Something needs to take its place which is significantly - not just incrementally better. I think a DSL-enabling programming language will fit the bill.
Another reason for thinking that the time is right for such a move is the whole XML experience. When applied to its sweet spot - documents - XML is essentially an excellent DSL. A language for expressing document languages. Significantly more developers grok this concept now than did before the XML revolution happened. These folks are ready to apply that same thinking to algorithms - programming languages. Even better, the blind alley of using XML as a DSL for programming languages has thankfully been explored and is being abandoned (thank goodness!).
All the stars are now aligned for the emergence of a mainstream DSL. Developers - hold onto your hats. This is going to be an exhilarating but bumpy ride into the future.
P.S.
Attentive readers will have noticed that I said "Programming languages are again starting to sprout DSL capabilities...". So this DSL thing has been tried before? Oh yes. There is nothing new in the world. Lisp Macros [11] are one example. Isn't it funny, how so much "new" stuff can be traced back to ancient old Lisp [12]?
[1] http://www.itworld.com/Comp/1044/nls_ebizcpu050125/
[2] http://agilemanifesto.org/
[3] http://www.ruby-lang.org/
[4] http://www.python.org/
[5] http://www.perl.org/
[6] http://www.parrotcode.org/
[7] http://www.erlang.org/
[8] http://research.sun.com/projects/plrg/faq/index.html
[9] http://www.haskell.org
[10] http://www.martinfowler.com/bliki/DomainSpecificLanguage.html
[11] http://www.apl.jhu.edu/~hall/Lisp-Notes/Macros.html
[12] http://open.itworld.com/nl/xml_prac/10252001/
