[Top][All Lists]

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

[Architect-discuss] [Fwd: Re: architect could become a valuable addition

From: David Horton
Subject: [Architect-discuss] [Fwd: Re: architect could become a valuable addition to GNU]
Date: Tue, 16 Dec 2003 20:05:53 -0600
User-agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.4) Gecko/20030701

Hi Everyone,

When I originally set this project up on Savannah I checked a little box on the web form that said something like, "I would like this project to become part of GNU." I wasn't sure exactly what that meant, but I figured, "why not?" Anyway it appears that they may be interested. I am forwarding a bunch of messages that have been going back and forth between the GNU people and me. Have a look if you are interested. (Start from the bottom and work up.)

Let me know what you think about all of this. Is it a direction you are interested in going? Is it what you envisioned Architect to be? Is there any part of the project you would like to help with?


-------- Original Message --------
Subject: Re: architect could become a valuable addition to GNU
Date: Mon, 15 Dec 2003 21:20:35 -0600
From: David Horton <address@hidden>
To: Steef Boerrigter <address@hidden>
CC: Karl Berry <address@hidden>,  address@hidden
References: <address@hidden> <address@hidden> <address@hidden>


Since the Architect project is in a very early stage it may be difficult
to judge exactly where it is headed.  Let me elaborate a bit on what I
have envisioned the Architect project doing (and not doing).  Hopefully
this will help you decide if it is aligned with GNU's goals.

In summary:

I would say that the Architect Toolkit is like LEGO.  It gives you a
bunch of pieces that you can put together in any form you wish.  You
could use your LEGO to build something that looks like the picture on
the front of the box it came in, but the true LEGO-maniac assembles the
pieces in an imaginative way to build something totally unique.  If GNU
wishes to use the Architect LEGO to build a GNU/Linux system that would
be great, but it should not do this in such a way that prevent the other
LEGO-maniacs from exploring their creativity.

In detail:

Architect should allow people to build any kind of system they wish.
When I say system, I use the word in a broad sense.  I do not want
people to feel that they must build a GNU/Linux system that looks just
like a disto from Redhat.  It's already been done.  This is what LFS
does in my opinion, that's why I compared it to a Sears kit house.  I
would like people to use their own imagination to come up with a system
design that is unique.  However I also understand that many people
probably really do want to build just another distro and I would not
discourage that.

Architect should provide tools to make the system builder's job easier,
but it should not be so completely automated that it obscures the
process.  This is why I have chosen to use shell scripts to build the
packages from source.  Most people should have an easy time
understanding shell scripts as they are so close to typing things
manually.  This is where the current release is very strong.  I feel
that there are currently enough shell script "recipes" to build a basic

Architect should work in layers and not try to do everything all at
once.  For example, the recipe scripts that build packages from source
do not tar/gzip the packages, nor should they.  A system builder may
want to use RPM's or DEB's instead.  For this I would leave it up to the
system builder to write another layer, perhaps a small script (or
makefile as you suggested) that calls the recipe scripts and then
packages the results.  I am hoping that people using Architect will be
willing to take on this task and then share their designs.  If there is
a large demand for a particular design I would like to incorporate it
into the project.  This is where I see GNU's idea of an easy way to
build a GNU/Linux system fitting in.  The GNU system design's makefile
would sit on top of the recipe layer and dictate the overall design
using the existing pieces.

Architect should provide instruction in areas such as system analysis
and design techniques, adherence to standards, design of effective user
interfaces, and so on.  This is where the current release needs the most
improvement.  I have not found the time to write many of these documents
although I feel that they are very important.  For example, I am a
strong believer in iterative design processes, taking small steps and
working in a spiral to achieve large results.  I also think that it is
important to observe existing standards unless there is a very good
reason not to.  This is why the recipe scripts take great pains to
achieve FHS compliance.  Please see my Pocket Linux Guide at to get an idea of my favorite design
techniques and standards.

On a personal note:

I started working on pieces of the Architect Toolkit because I wanted to
experiment with building specialized systems like network appliances,
thin clients or other small footprint devices.  I wanted to do this in a
way that did not include instructions like: "start with the Distribution
X base image and remove this and this and then install that and that."
I realized that in order to do that I would need to start building
pieces from source and interconnecting them to build my desired system.
 In the process I found that it was easy to document what I was doing
by writing the steps in a shell script with comments.  While working
with The Pocket Linux Guide I encountered several people who wanted to
pursue similar things.  I began sharing my recipes for building packages
with those who were interested.  Recently I started the project on
Savannah to make it easier for people to get involved, share the work
and to separate discussions from the Pocket Linux Guide mailing list.

I hope this gives you a better idea of what I am envisioning and how it
may fit with GNU's goals.  Please let me know if there is anything that
needs clarification.


Steef Boerrigter wrote:
Hi David,

I have been asked by Karl Berry to discuss architect a little bit further with you. We, the GNU evaluation team, have had extensive discussions with Richard Stallman to see if architect could be part of the GNU core system. The point is this: as we have already noted before, there are several projects scattered around the internet already which provide the methods to build a GNU/Linux system from the sources. Since most of those projects are already free (maybe not GNU, maybe not GPL, but still free) there is really no reason to incorporate a package which does a less good job than those packages. GNU has no reason to reinvent the wheel, if you know what I mean. By it's approach Linux From Scratch (LFS) seems to do almost exactly what you have in mind. It is essentially a book describing the whole process of incorporating a new partition on an existing unix-like machine and work all the way up to a clean install of a working GNU/Linux system. In itself the LFS documentation is quite verbose and reaches deep into the background information, explaining every step in the process. LFS also supplies the necessary patches to all the recommended packages to make sure everything works nicely together. In that respect, your analogy of architect being the academic study to build a house versus hiring a contractor, LFS does that job already. In other words, by reading parts of LFS, we find that it really does a much better job than providing "a Sears do-it-yourself-kit home".

It may take years to get architect to reach the same level as LFS, and as such, would be reinventing the wheel.

However, as we've discussed architect may still be a very valuable addition to the GNU system. One of the points where GNU is lacking is that at the moment it is basically a huge collection of packages, all of which stick to the standard of doing something like:
tar xzf 'package.tar.gz'
cd package

I don't have to tell you how much work is involved in building an entire GNU system by downloading all sources and going through this process manually. What we feel would be of utter importance to have included in the GNU system is a package which can do something like this:
tar xzvf architect.tar.gz
cd architect
./configure --with-shadow-passwords --without-Xfree --with-libc5-support --strip-binaries etc.etc.etc. (you get the picture)

Then the created Makefile will build all the packages, maybe apply some patches to make a congruent system, and install them either over the current system, on a new partition or wherever one desires. Makefile could even go as far as downloading the required packages from if they are not already available on the system. Whenever one of the essential core Gnu packages gets updated these updates will go in architect to keep the system updated and all parts working together nicely. Also, whenever packages require updated versions of other packages, these dependencies can easily be checked by the architect and the required updates can than be applied. In the process, as all GNU packages should have, extensive documentation of what the package does, how it can be fine-tuned and customized is more than welcome. People that make customizations can do this by adding features in architect, making them available to everyone. In that respect your philosophy behind architect seems to be overlapping for a great deal with what GNU needs!

Of course, the above may be not at all what you had in mind when you started to work on architect and it may seem something you don't want architect to do. I feel, however, that it is a natural spin-off to make a comprehensive build system in the process. In fact, in the current distribution of architect you have yourself already provided the scripts to build the packages, which is already a first step.

In the beginning, architect will only just build the core system, which, mind you, will already be quite an achievement. As more and more people join the architect development team, more and more packages will become supported, making the GNU/system more complete all the time. As the project progresses, more and more developers of packages will eventually want to contribute their added packages to support the architect build system, to see that their software gets incorporated into the system.

Tell us what you think of what we propose here, and if you would like to see yourself as part of that development effort, maybe bending the pathway that you had in your mind for architect a little bit.

Steef Boerrigter

David Horton wrote:

Hi Karl,

I am familiar with the Linux From Scratch project and I do believe that my project is fundamentally different. In brief, LFS is about building and The System Architect Toolkit is about designing.

To point out the differences, let me use an analogy.

Think of a GNU/Linux distribution as a house. There are a few options about how you can obtain a distribution just as there is more than one way to obtain a house.

Option 1:

You could buy a pre-made distribution from Debian, Redhat, Suse, etc. This is like buying a new home built by a housing developer. You have some control over a few options like the style of kitchen cabinets and the choice of hardwood or carpet on the floor, but otherwise your house looks pretty much like every other house in the subdivision.

Option 2:

You could shun the traditional distribution and build LFS instead. I think of this as the Sears Roebuck kit home ( that was popular in the early 20th century. The major difference between the Sears home and a housing developer's home is that you have supplied the labor to build the kit home rather than using a contractor. You build the home yourself, but someone else has supplied all of the plans and drawings with exact measurements. So in the end you have a house that looks like every other Sears kit home sold that year.

Option 3:

You could enroll in the architecture degree program at a local college and learn how to design your own home. You would draw up the blueprint for whatever type of house you wanted, but to save time you would hire sub-contractors to do the labor. In the context of The GNU/Linux System Architect Toolkit it would work like this:

* You would use the toolkit's documentation to supply your architect schooling and learn about system design.

* You would use your own knowledge and creativity to design whatever type of system you desire.

* To save time you would use the recipes and system scripts like sub-contractors. (Recipes build binary packages from source code.)

I realize that many people will probably want to use The Toolkit to build a traditional GNU/Linux distribution and that's fine. But I hope that some people will use The Toolkit, coupled with their creativity, to come up with some truely unique systems.

If you need any more information or clarification, please let me know.


>> Karl Berry wrote:
>>> Hi David,
>>> Thank you for offering your architect package to GNU. Steef (cc'd here)
>>> and I are two of the evaluators helping rms evaluate new packages for
>>> GNU.  (I apologize for the delay in responding, we are badly
>>> backlogged.)
>>> In doing some web searches, I came across the LFS project,
>>>, which seems to be essentially the same
>>> thing, but they seem to be rather further along.  I wonder if you could
>>> take a look?  If you have fundamentally different goals than LFS, that
>>> would obviously be important to know.
>>> Thanks again,
>>> karl

reply via email to

[Prev in Thread] Current Thread [Next in Thread]