[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Architect-discuss] [Fwd: Re: architect could become a valuable addition
[Architect-discuss] [Fwd: Re: architect could become a valuable addition to GNU]
Tue, 16 Dec 2003 20:05:53 -0600
Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.4) Gecko/20030701
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
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.
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.
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
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
http://www.tldp.org/guides.html 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
Steef Boerrigter wrote:
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
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'
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
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
./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
ftp.gnu.org 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
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.
David Horton wrote:
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.
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.
You could shun the traditional distribution and build LFS instead. I
think of this as the Sears Roebuck kit home
(http://www.arts-crafts.com/archive/sears.shtml) 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.
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
>>> and I are two of the evaluators helping rms evaluate new packages for
>>> GNU. (I apologize for the delay in responding, we are badly
>>> In doing some web searches, I came across the LFS project,
>>> http://linuxfromscratch.org, 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,
|[Prev in Thread]
||[Next in Thread]|
- [Architect-discuss] [Fwd: Re: architect could become a valuable addition to GNU],
David Horton <=