John Rose, a key designer behind Sun's new Da Vinci Machine Project initiative, contrasts dynamic language support and optimization on the JVM and Microsoft's Dynamic Language Runtime.
Sun announced today the Da Vinci Machine Project, an effort aimed at creating JVM extensions to support dynamic languages as first-class JVM citizens. Writing about the growing interest in new programming languages on the two main runtimes—the JVM and Microsoft's CLR—Sun's John Rose remarks in Bravo for the Dynamic Runtime, that:
The DLR (with IronPython and IronRuby) is another evidence that we are in some sort of renaissance or resurgence of programming language design. For some reason, people are inventing programming languages again in a big way, expecting to get audiences, and sometimes getting them. I think the “some reason” is a combination of better tools and higher-level runtimes and cheaper CPU cycles and the open source movement.
Rose points out that many ideas currently being implemented on top of the DLR and the JVM have been around for decades, but that new circumstances favor a fresh look at old programming language notions:
These new conditions are combining in a deep and exciting way with some very old ideas. (I mean “very old” in the field of computing, dating back no more than fifty years.)...
Somehow the basic ideas were sketched early. I am thinking of distinctions of syntax (concrete, abstract, and “sugar”), data structures (including procedural, object-oriented, functional, symbolic, and relational), the idea of exploratory programming, full inter-conversion between program, data, and text, declarative versus imperative notations, lexical versus dynamic versus message-based scoping, maximal versus minimal versus extensible languages, closures, continuations, reflection, garbage collection, caching, lazy evaluation, and more.
In the rest of his blog post, Rose discusses the similarities and differences between dynamic language support on the JVM and the DLR:
[There is ] a striking case of parallel evolution between the DLR over the CLR on one hand and the Da Vinci Machine over the JVM on the other side... In my work on JVM dynamic invocation, I knew I was applying tried and true ideas from Smalltalk, Self, and CLOS, but I was encouraged to find that a colleague (and competitor) had been busy proving the practicality of those ideas.
I realized (as I said above) that systems built on Hotspot and other JVMs are sitting on a gold-mine of performance. While IronPython on the DLR has to do hard, brilliant work to “iron” out the wrinkles in the CLR JIT’s weak performance profile, the “irony” is that Hotspot has already been optimizing highly dynamic programs for almost a decade. JRuby is already tapping our gold mine of JIT optimizations, and showing benchmark performances even greater than the original C-coded version of Ruby. It can only get better from here.