Slate is Bootstrapped

aster_ken writes "The latest Slate compiler is finally able to compile itself. To quote the website: "Slate is a prototype-based object-oriented programming language based on Self, CLOS, and Smalltalk. Slate syntax is intended to be as familiar as possible to a Smalltalker, rather than engaging in divergent experiments in that respect.' The beta release is currently being written in Common LISP." The latest version of Slate, 0.3, is now available for download. It was previously mentioned in this Slashdot article."

Comments

Re:Common Lisp?

[WolfWithoutAClause]

Yeah, it's boostrapped- he used CLisp to write a Slate interpreter, then using the Slate language he wrote a new compiler/interpreter, and then compiled the interpreter/compiler to machine code; then he restarted Slate running on the new compiler/interpreter; and CLisp is gone now. Any future changes to the compiler will be self compiled.

'Job's a good'un'.

Cool

[jefu]

I played around with Self a while back and was very impressed by the potential of prototype languages. There are some problems, but so many possibilities.

Now there are several such languages available (other than slate). Once they're all a bit more stable (some are stable now) it will be interesting to do a bake-off and see how they compare.

These seem to be the most influential and active (at least at the moment) :

• Self for solaris, x86, several web sites
  
• Cecil
  
• prothon prototype language in the python mood
  
• IO Desktop
  

Are there other major/active languages in this vein?

Re:Cool

[bmac]

Yup, good 'ol Javascript & ECMAScript.

Have fun.

Peace & Blessings,
bmac

Re:Cool

[aero6dof]

Sorry, must remember to preview...

Hmm, maybe I'm misunderstanding what you mean, but you can modify and clone instances in Ruby:

ob = Object.new
class << ob
def hello
puts "world"
end
end

o2 = ob.clone
o2.hello => world

From an author - Glad to see the interest now

[water451]

So it looks like the original story here wasn't such a fluke after all. I was really kind of shocked that anyone would even look at it or want to use it given that it was written in Common Lisp for experimentation.

The language we write the system code in is currently not quite Slate, but it's designed to make the C code more consistent and relatively safe. We spent some months debugging the new implementation, so this release is focussed on being debugged. Future releases will have more features, and so forth.

And, no, I still don't care about the online magazine of the same name. Just think of it as "Clean Slate" Smalltalk or Slate Smalltalk. Too many other things are named Slate or some variation thereof, anyway (see the USPTO's registry).

My partner on the project plans on full compilation without a C back-end, but also that it will take time, so I can't promise you guys a darned thing yet - don't hold your breath! (He's a talented guy, and great to work with, but things like this take time to develop.)

Re:From an author - Glad to see the interest now

[water451]

I realize you're joking, but that's actually what the original implementation did, up to a point (and it was decently non-abyssmal in performance). We had an inlining semi-compiler (to avoid the fact that Lisp implementations differ, you can't rely on specific ANSI-variable behaviors) with a few critical optimizations applied which we are now applying to the VM-based implementation (some are already present).

Let me just say that ANSI Common Lisp makes for a really poor virtual machine; that's really not what it excels at. It excels at optimizing Lisp programs, not other languages with a substantial impedance-mismatch. Slate super-heavily relies on polymorphism, and this just isn't something that Lisp compiler implementors focus on optimizing.