On Wednesday 27 June 2001 17:51, Glen Starchman wrote:
> > I pick Jam because (i) i love it ;-) (ii) Jamfiles are platform
> > independent (with a little preparation), small, and easy to read/write.
> > (iii) you can build the default build environment into the binary (iv)
> > make sucks.
>
> I have been round and round on the python mailing lists regarding a
> similar issue, but I am on the opposite side of the fence from you. 

Aha! A worthy opponent ;-)

> I
> would prefer to *use* make, rather than create yet another abstraction
> in the build process. With Python they added the DistUtils package.
> DistUtils, while a wonderful piece of software, seems to me to
> complicate the build process by forcing me to write a python script in
> order to build a makefile.

I think some abstraction in the build process when you want to build on 
multiple platforms is a Good Thing - particularly the platform specific bits. 
You should be able to specify which binaries are built from which libraries 
and sources in a platform independent way.

Jam's a complete make replacement with nice clean syntax, in much the same 
way as ruby is a complete replacement for perl with nice clean syntax ;-). 
IMO a de-facto standard is only worth using if it is well suited to the task. 
Make isn't.

> I prefer to use the Autoconf/Automake tools to build a makefile. My
> reasons: 1) make is, like it or not, a standard that isn't going away
> anytime soon, 2) I develop 90% of my software on some flavor of Unix,
> so I don't have to deal with MS's nmake, 3) Using Autoconf allows me a
> single point of failure! Yes, I don't have to dig through ten different
> scripts to find out why my build failed, 4) other (competent) developers
> understand Makefiles... how many people use Jam?

1) Yes - unfortunately.

2) Others do.

3) Single point of failure? A single point of change perhaps, but there are 
many points of failure in the autoconf process. That said, you can use 
Autoconf to configure your make rules, and in the same way you can also use 
it to configure your Jam rules.

4) Many. Jam is actually very widely used and has (apparently) even been 
embedded as the build tool in the new Mac OSX App.Builder IDE.  OK, it's not 
as widely as make, but there's a thriving Jam user community out there. 

This point is largely moot though since if we're talking about competent 
developers, then they will find Jam much easier than make and even the less 
competent should cope. Here's a sample from the Jam homepage:

Main smail : main.c map.c resolve.c deliver.c
                 misc.c parser.y alias.c pw.c headers.c
                 scanner.l getpath.c str.c ;

That small Jamfile contains everything needed to compile the .c files into .o 
or .obj files depending on the platform and then to link smail or smail.exe 
from those object files. It also creates useful pseudo targets like 'clean' 
automatically, and it will also scan the .c files for #include's and update 
the dependency graph accordingly. How much easier could it be?

Tony
=====================
Tony Smith
tony at smee dot org
=====================