kernel bytecode vm?

[Mariano Guerra]

hi! I was playing with a simple kernel implementation of kernel on pypy and asking on IRC
they told me that pypy is better with bytecode VMs.

how would a bytecode kernel implementation look like?
is it possible?
any limitation?
any pointers on where to start looking?

[Andres Navarro]

Sorry I took so long to reply.

The problem with writing a bytecode kernel implementation is that in order to
do that you need to compile the kernel code down to bytecode, which in
principle is not that much easier than compiling kernel code in general (where
in other languages it's much easier).

As all of you know, compilation of kernel code is still an open topic.

It's certainly possible to compile it making certain assumptions (such as stability
of environments, etc) and Oto has done something along that lines last year.

It's also possible to work with certains subsets of kernel that are easier to reason
about, and try some kind of abstract interpretation to find more info about bindings
and that was my line of work with fklisp in February (it's in standby, I'll resume work
on it probably next year),

But it's certainly not easy to do a general solution which is trivial in more static
languages like lua (because of reserved keywords and the ausence of macros),
and even in scheme (because of the preprocessing nature of macros vs fexprs,
the unavailability of first class environments and restrictions on eval, among others)

So in principle I am tempted to say it's no possible for the moment.  As we come to
understand better how to automatically reason about kernel code, I am hopeful that
this will become a possibility in the future.

Regards,

Andrés

--
You received this message because you are subscribed to the Google Groups "klisp" group.
To unsubscribe from this group and stop receiving emails from it, send an email to klisp+un...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.