Welcome to the next generation of the Slate programming language

[Timmy Douglas]

Please join us online at:

Google Code Project Page with bootstrap images and stuff:
  http://code.google.com/p/slate-language/


*Please* join the new mailing list:
  http://groups.google.com/group/slate-language


New source repository:
  http://repo.or.cz/w/cslatevm.git


Over the last year, I've been rewriting the slate virtual machine in
order to make it faster and portable to my 64-bit machine. I've gotten
to the point where I can now bootstrap slate on my machine and run
slate faster than I ever could in the past. I would like to invite
everyone to participate because I don't have enough gas to keep this
running myself.

There are a lot of changes I made in the last year and I'm sure I've
left out some:

* I got rid of pidgin and now the VM is in pure C. It is a lot cleaner
now. It is also easy to maintain and you don't have to worry about
generating the whole thing through pidgin again.

* I rewrote the garbage collector to a simple generational
collector. Young objects are allocated in another region and compacted
until they have to move into the old region (where objects don't
move). When moving young to old, we scan the whole old area so freed
old holes are used before growing the old size.

* I changed the compiler to produce SSA register based bytecode
instead of stack based bytecode. It seems to run faster and I think
this bytecode is easier to read and will be easier to inline if we
decide to do that for performance in the future.

* I changed the binary format of the image file to waste more space
and do less bitmasking of object fields. I removed the payload type
object and now I just have another field for the object size. This
made the VM/gc/etc simpler.

* I've rewritten the GUI (graphics.slate/SceneElement) code so that
now the SDL/Cairo library is about up to par with what we left off
with. We have listboxes, textboxes, buttons, and I'm working on a
LineEditorMorph which is like a multiline text editor.

* I grew the global function cache and now I've added callee caches to
each method. This is pretty much like a polymorphic inline cache. I
thought I fixed a bug where it flushes the cache when callee get
redefined but I'll have to check and make sure that code works.

* I removed delegate slots because they were complicated and hard to
follow. Now you just have "delegates" which is an array in the map of
an object. Easy to modify and understand.

* I added primitives to get the time in microseconds since the epoch,
fork the process, and create sockets. I started implementing a socket
interface to postgres but lost interest. You can log in to a database
and execute simple queries.

* I gave the VM much better debugging capabilities, you can now print
a stacktrace from within the VM with print_backtrace and you can look
at objects with print_detail and print_stack_types. These make
debugging the VM a LOT easier. There are also a lot of build flags
that you can find in the Makefile.

* I migrated the source to a git repository which seems a little more
stable than darcs was for me. They probably fixed those problems with
patches taking forever to merge a few years ago but git is more
widespread now.

* The VM is now in one C file less than 7000 LOC. Some people might
not like this style but it's a lot easier to understand and find
things I think.

* There have been lots of various bugfixes to slate files and we
probably need a unit test framework if we're going to find them all.

There might be more things but that is the gist of it. I only have an
amd 64 box to test on, so please try your luck by downloading a kernel
image from the google code page and compiling the vm sources.