The new thing is "gradual typing"...
I always like to know the origin of a name. In this case, gradual refers to the idea that in a gradually typed language, you can gradually add type annotations to what is otherwise a dynamically typed program.Sounds like you need better tools (they pretty much stink for Python and Ruby, try Smalltalk or Lisp) and perhaps a better compiler (ditto). Doubtful you need "gradual typing".
Another data point on the idea of languages implemented in layers, consider this... ("why you should care as a programmer about the study of programming languages")... (pdf)... Dan Friedman's talk at UNAM, Mexico, on April 27, 2001... quoting his student Jonathan Sobel:
“That was the amazing part: I had produced a program that I could not have written, and in any case would not have wanted to write.”Sobel wrote a program in a simple, direct style using Scheme and then applied several transformations, from Scheme to Scheme, each a fairly simple transformation. The final transformation was ready to be translated into a C program using another simple transformation.
The efficient C program does not have to be maintained. Just the original, simple Scheme program. Probably programming in C itself (or Java or Scala) is a kind of premature optimization.
Ola Bini writes about the concept of a "stable layer" for language implementations, especially (I gather) where the "stable layer" is underneath a "dynamic language" used by application programmers. I am using quotes because these terms do not have to my knowledge widely accepted, rigorous definitions. That's OK, coming to a common understanding of these terms is part of it.
I interpret his use of "stable layer" as perhaps an "implementation layer", what is used to implement the language one truly wants to use. Maybe they are the same language. If you want to program in Java or in Scala, then it would seem in these terms, the stable and the "top" (?) layer are one and the same.
CPython, CRuby, Jython, and JRuby have as "stable layers": C, C, Java, and Java, respectively. But this arrangement is not necessary for dynamic languages generally. My understanding is PyPy is implemented in Python and Rubinous is implemented in Ruby. (Excuse me if I messed that up a bit.)
As a couple of other data points on suitable languages for a "stable layer" consider the implementations of Squeak Smalltalk and Gambit Scheme. Both of these languages are implemented in subsets of themselves. Both of those subsets compile to C primarily to avoid implementing special translators for each instruction set architecture they run on.
Those subsets (of Smalltalk and Scheme) are essentially as efficient as C. But they are each "dynamic languages". And the stability of both implementations can be measured now in *decades*, regarding how long they've been around, used in "real" systems. Gambit in particular having very good performance because *any* application code can be compiled this way, and Squeak could take this same approach if desired.
