[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

SEUL: Development methods

> I thought Linux was a quality product, isn't it?
Parts of it are of extraordinary quality.  Other parts are not.  And there's 
still the issue that Linux, as far as interface and quality are concerned, is 
far from self-consistent (in the big picture).  Windoze at least looks the
same and crashes the same way (almost) every time. :-)

> Admittedly, it's only as 'consistent' as necessary.  Linus Torvalds DIDN'T
> sit around thinking and planning like we're doing, he wrote code.
Linus wasn't writing a UI, was he?  Kernel design is a well-researched 
and well-published process.  He simply managed to do it better than anyone 

> He wrote code to do what he wanted it to do, and it just so as happened that
> other people agreed with him, and wanted an OS that did what they wanted,
> too.
He wrote a kernel with a license that others liked, and a philosophy that 
worked.  It was not his goal to make a user-friendly OS, it was his goal to 
create an alternative to Minix.  He succeeded in a big way.  But in order for 
SEUL to succeed in a big way, we have to at least spend *some* time 
considering being self-consistent, which wasn't nearly as big an issue for 
the kernel (which had much more limited, though similarly lofty, goals).
Each person building their own tools in isolation, or even in small groups,
does not build a self-consistent system.  Communication, and thus planning, 
is the key.

> We're not constructing a building, we are(in theory) making a distribution.
> When you construct a building, you draw blueprints and a plan and execute
> the plan directly with no intermediary steps.  When writing software,
> however, you HAVE to take small steps.  Only a moron implements a pile of
> major changes AT THE EXACT SAME TIME, without testing each independantly.
You just described the same process, once positively, once negatively.  While 
putting together a building, you can't build small pieces of the structure at
random locations "at the exact same time" and try to put them there without
a foundation or frame.  You drive the piles, test them.  Pour the concrete, 
test it.  Pour more, test it.  Frame it in, test it.  Ad nauseum.  Identical 
process here with software.  You must build the framework before you can 
flesh out the system.  The framework can't be built without blueprints.

> > Do this with 200 people all writing things to solve their own personal
> > problems with the system, and you have a completely unworkable mess of
> > duplicate software packages with narrow focus and very little usefulness. 
> > 
> No, you have Linux.
Precisely.  An end-user presented with his/her choice of anything (s)he 
wanted from all the archives, and they would say exactly what I said above.  
I did not say there there aren't any good packages, and I didn't say that
there isn't enough usefulness to put together a decent system.  We have RedHat 
(4.2), what more proof do you need?

OK, here's the deal: I do not want Linux to fragment like BSD did.  I don't 
know all the circumstances behind the 4- or 5-way split, but I think it had 
something to do with lack of communication.  One group wanted it to go one 
way, but maybe wasn't completely successful at it, so they split off to 
create their own.  They had the same problems, and you get another split.

In Linux, we have almost the opposite situation: multiple groups starting up 
almost simultaneously, and spontaneously, with similar goals.  Unless we can
coordinate *all* these efforts, we will become as fractured as *BSD.  This
works both at the small and large scales, so I'm trying to avoid not only
duplication of effort, but the strife that comes when one person's code is
chosen over another's, and this is repeated throughout the entire system.  
It is much better to decide up front what to do, and have everyone who would
have done it by themselves work together instead.

Comments, please.


     Erik Walthinsen <omega@seul.org> - SEUL Project system architect
       /  \                SEUL: Simple End-User Linux -
      |    | M E G A            Creating a Linux distribution
      _\  /_                         for the home or office user