Strange LispOS dream.

[Harvey J. Stein]

The following message is a courtesy copy of an article
that has been posted as well.


I had a strange Lisp dream last night.  I suppose that could be
considered redundant.  Maybe any dream involving Lisp should be
considered strange.

In any case, I dreamt that I was fiddling around with a Linux kernel
driver (loading it into the kernel, debugging it, etc) , but the
driver was implemented in Lisp.  I remember dropping into the debugger
to watch packets make their way through the driver.  I think CMUCL was
involved.

Now that I'm awake, I can think of a few ways this could be done.
Write a loadable kernel module in Lisp & use CMUCL or RScheme or some
other Lisp compiler to compile it.  How hard would this be?  It'd
certainly be pretty cool - as a general concept and for those who want
to do that LispOS kernel hacking.  Another possibility would be to
actually build a kernel module out of a Lisp implementation.  How hard
would it be to make CMUCL or RScheme into a loadable kernel module?
Then you could load additional modules written in Lisp which make use
of CMUCL or RScheme.

CMUCL & RScheme are but two examples, but they give a good range in
that RScheme compiles to C code, so for RScheme to be in the kernel
one would also need the C compiler in the kernel, at least for that
last bit of dynamic oomph.   I suppose one could use the user side
RScheme to compile code & load that into the kernel RScheme module.

On the other hand, CMUCL compiles directly, so it might be easier to
build it directly into the kernel.

Any takers?

-- 
Harvey J. Stein
BFM Financial Research
hjstein@bfr.co.il