Benevolent Dictatorship

Chris Bitmead
Fri, 20 Mar 1998 14:54:37 +0000

I tend to agree that 1 line of code is worth 100s of lines of
discussion. One would hope that once we have something, then if
it is bad, it will be replaced eventually. If we have nothing,
chances are it will tend to stay nothing.

Personally I would like to see something that does the main
things that we want even if it is appallingly slow, and awfully
ugly and riddled with  hacks.  Once people understand what we're
aiming for they will be motivated to make it elegant/fast. But
having some terribly clever and elegant ideas that aren't
actually implemented, will leave us.... well where are now.

In my opinion the way forward is to build it on top of Linux for
now. The reason is

1) It saves enormous amounts of work that we can't afford now.
2) It allows us to ignore the compatibility issues for now. We
can still run UNIX programs straight away.
3) Rebooting into a different OS that doesn't do anything isn't
4) More people will try it in the initial stages if they don't
have to go through the headaches of a different OS.

In the future, someone will be inspired to allow removal of Linux
from underneath. Personally, I'd like to see the ability to use
UNIX underneath as an option that stays. We can't change the
world in a day.

Now, when I said I'd like to see something with the "main" things
in, even if they are slow/ugly, everybody has their own idea of
what is important.

To me personally I think the persistent object system is key. I
don't see enormous advantages to a lisp os as opposed to just
running lisp on UNIX without this. 

I also personally want to see Scheme as the language, because I
havn't come to terms with all of the Lisp language yet. Plus also
I think most people agree that Scheme, in terms of it's base
language is an improvment. And if we are going to try to
challenge every accepted notion of what an OS should be -- well
hey --, might as well go the whole hog.

So, when I see a Scheme running on UNIX that has a neat object
system, then I think we have a way forward. Until then it all
seems too hard to co-ordinate.

Just my opinion. Anything that gets started has to be good.
Rainer Joswig's list of things to do would be a great start. What
I think we need is one of the Scheme gurus like Paul Wilson to
get interested in this project. Maybe we should use his "RScheme"
as is -- it already can be used with a persistent object system,
is supposed to be terribly terribly elegant, it's fast, has a
true compiler.

Here's a job that anybody could do, and it's not so hard. Look at
all the Scheme implementations and find one that is closest to
what we want, and then we should agree to just start using it.

Chris Bitmead