Interpreting code is like checking a map at every step: It can really slow you down.
The goal is to execute (not interpret) object oriented code without external dependencies, on modern hardware.
This means compiling dynamic code into binary. Using several intermediate representations it is possible to keep track of type changes and switch between differently typed, but logically equivalent, versions of methods. As the system is 100% in ruby, the ultimate goal is to carry on the compilation at run-time, ie after the program has started. No interpretation.
Using the compilation method on it's own runtime (and bootstraping with an exising ruby), it is possible to write the whole system in a dynamic oo language (ruby), thus removing the two language problem (having to choose between nice and fast)
Work is progressing on the ruby compiler. This uses a pure ruby parser to create:
The lower level, strongly typed layer is finished. While it has well known typed language data semantics, it introduces several new concept:
An abstract risc like register level defines some abstraction from the actual hardware. The type compiler compiles to this level, but a mapping to Arm is provided to produce working binaries.
There is also an interpreter (mostly for testing) and a basic visual debugger which not only helps debugging, but also understanding of the machine.
The short introduction is under the architecture menu.
The section on the intermediate rerepresentation is here.
The about section has some info of when and how this started. If you feel like contributing read this or write a mail .
Last but not least, i try to get recent developments down on paper when they are still fresh.
{{ site.posts[0].date | date: "%d.%m.%y" }}: {{ site.posts[0].title }}
{{ site.posts[1].date | date: "%d.%m.%y" }}: {{ site.posts[1].title }}
{{ site.posts[2].date | date: "%d.%m.%y" }}: {{ site.posts[2].title }}