Benevolent Dictatorship

[Kragen]

On Thu, 19 Mar 1998, Gavin E. Gleason wrote:
> 	We will need some way of deciding how to procede given
> disagreement as to the next step if we cannot agree unanimously.  I
> think that it is possible that the need/want for a lisp OS will
> supercede our ideas about the "best" way to proceed.  Maybe we should
> use some sort of parlimentary procedure, and have an elected
> chairman.  We could put motions on the table as to the steps as they
> become pertinent.  Then we could vote as to which would be the best
> way to continue.  

I suggest another way: a sort of economy, like Linux.

Someone -- one person, or two people in close geographic proximity --
gets something working, puts it on a web site, tells other people about
it.  Sort of pitches it to them, but tries to do it honestly.  Other
people download it, try it, make patches to it, send it back.

If they don't like it, they can write their own.  If they do like it,
they can make it better.  Instead of deciding on things by majority
rule, we can decide things by trying them out and seeing what's
extremely cool and what's sort of lukewarm.

If someone thinks that xyz feature should be implemented a different
way, they can implement it that different way, put the source on their
website, and tell other people about it.  It will be discussed.  Some
people will decide to patch their copy of xyz one way, and some the
other.  Eventually a consensus will arise, as most people decide to
do xyz one way.

Some people are likely to be more influential than others -- because
they have more time to write code, because they write better code,
because they make better decisions, or because they piss people off
less.  That's OK.

> But I have a feeling that the initial stages may be the most
> difficult to agree opon. 

I agree.  I think someone needs to get *something* working and make it
available *first*.  Then they need to run something on it, preferably
something *cool*, so other people want to run it.  Maybe someone could
kludge together enough of a Linux-kernel framework to use Linux's TCP/IP
stack and device-driver support, put in a small Lisp VM, a read-eval-print
loop, and write a simple web server.

Even this small task is beyond my poor abilities, though.

> 	1. scheme or lisp.  Yikes!  Thats a dangerous one :).  I don't 
> personally care either way.  Scheme is definitely cleaner, and it
> would seem ideal as a starting point for a clean and radically
> different OS.  Lisp on the other hand has everything already built
> into the language.  I'll lean whatever way seems most popular in the
> interest of getting this show on the road. 

I suspect that this choice is inconsequential.  I think it'll be fairly
easy to support either Common Lisp or Scheme in the same OS framework.

> 	2. Bootstraping.  This is a particularly difficult question,
> as the FLUX OS toolkit is unavailable.  I think that we should open the
> table for motions on options in this catagory

Someone write something.  Or adapt something.  FreeBSD and Linux both boot,
and we could use either of their code.

> 
> 	3. Abstractions.  Finding the most basic level of abstractions 
> that we intend to provide in our system will be difficult because we
> will have to come up with a ideas that will be useful in practice.
> This will probably be a dynamic variable that changes as coding and
> practical issues arise, but we should at least have some idea of where 
> we are going. 

Yes, I agree.

Kragen