The next 1000 languages will most likely be dynamic, or declarative, or pure, but most certainly increasingly functional, with type inference, or pattern matching, or algebraic data types, but most certainly a rich set of concurrent primitive and/or models… or more likely a combination of some or all of those things. The real question is, what languages will the next 1000 languages be written in? There was a time that the first and final answer to this question was C, but today there are a few more viable options. It’s a good time to be a polyglot.
There is little doubt that the JVM is king right now as the chosen platform for some truly exciting langdev projects. From Clojure (my current favorite), to Scala (a recent addition to my workplace), to JRuby, to Jython, to Rhino, to Groovy, to Beanshell, to SISC, to Nice, to Fan, the JVM is hot stuff, and deservingly so; it’s a beautiful piece of sofware. That is, it is a beautiful piece of software, for running Java. In order to get all of these other (dynamic) languages to run on top of a system that is geared toward running a static (not in the type-system sense) codebase many hairy tricks are employed. However, there is a light at the end of the tunnel in the form of the Da Vinci Machine project that is working toward making the JVM a viable target for dynamic languages. I fully expect a flood of new languages will be built on the JVM after the Da Vinci changes take effect (there have recently been some talk about what InvokeDynamic tastes like).
There are currently three big players currently on the .NET platform: Iron Python, Iron Ruby, and the exciting F#. Of course, this does not include C# itself, VB.NET, ASP.NET, etc… However, aside from this core of big languages, there are very few additional language projects going on. Of course there is Boo, Cat, Cobra, and even Scala, but the pickings are slim. Why is this? Who knows. Perhaps it has to do with the fact that many .NET developers are weekday warriors and simply are not interested in the platform outside of it facilitating their ability to draw a paycheck. Likewise, perhaps the FOSS community inevitably sees .NET as evil and is avoiding it. Maybe it has to do with the fact that dynamic languages are not fully supported, although that has not seemed to hurt the JVM (note: the Dynamic Language Runtime is working to fix this). It could be that the .NET platform is already loaded with languages (although they mostly seem to be different faces on C#). My guess is that the answer lies in some combination of the above. Whatever the reason(s), my guess is that eventually people will start targeting the CLR/DLR. Actually, most languages will likely target both the CLR/DLR and the JVM.
I predict that in the future people will compile all languages into quadruples which will then be converted to all necessary bytecodes.
Yeah, I do not believe that either, but there may be an interesting PhD thesis in their somewhere…
Of course people will still create languages using C; I’m not insane. However, it’s monopoly is forever broken.
There is this strange language called Perl that has apparently been around for a little while now and supposedly there is this really cool VM called Parrot that it will run on that supports dynamic languages out of the box. However, both are somewhat vapor-ish, but all of the propaganda coming out of the Perl camps are exciting, if not weird.
So apparently Erlang runs on top of its own VM and supposedly there are one or two languages out there targeting it, but I have a hard time believing that trend will expand any time soon. However, (and I speak from now actual knowledge) the big win is that presumably the Erlang VM provides concurrency operations, which, unless you’ve lived under a rock, is the wave of the future (and all futures both past and present).
Future Language X