Status of libtool 2.2.X?

[Ed Hill]

On Wed, 03 Dec 2008 10:22:00 +0100 Kevin Kofler wrote:
> Ralf Corsepius wrote:
> 
> There's an alternative which is:
> * easier to learn,


OK, I see a lot of vitriol on this thread but its an important topic
so I'd like to offer a (hopefully) positive persepective and then ask
about the learning part.  I want a build system that has the following
features:

 required:
 + build for multiple OSes (Linux, some *nix, and an occasional 
   windows build -- where mingw may be sufficient)
 + multiple-language compilation and cross-language linking
   (C/C++, Fortran, MatLAB/Octave MEX, various scripting
   languages, etc.)
 + creation of *both* static and shared libs for C/C++, Fortran,
   etc.
 + good documentation and examples -- where "good" means the docs
   explain what are good strategies/approaches to use for non-
   trivial projects and *why*
 
 desired:
 + allows either "in-tree" or "out-of-tree" builds
 + parallel and/or distributed builds that actually work


So far, my build system experiences have included:

 + Plenty of "homegrown" makefiles (both of my own shameful making 
   and from others) -- have learned the hard lesson that it is
   exceedingly difficult to try to re-implement the flexibility of,
   for instance, the Gnu autotools
 + Gnu autotools -- have used them on-and-off for years and have 
   become somewhat comfortable with them -- have run into many 
   problems (mostly of my own making) but, over time, things keep
   improving and I keep finding (or learning from others) ways to
   better use the tools provided
 + Boost Build (aka bjam) -- this is a Jam implementation that
   was created by the Boost folks and, in my opinion, it has a
   number of serions problems since:
     - the jam language is poorly documented and not easy to 
       grasp -- learning a yet-another new language is just 
       more lost time -- and it seems that you have to keep 
       fighting with the Jam files to get anything accomplished
     - poor support for non-C++ languages
     - error messages are simply awful
     - documentation does a lousy job of explaining how you
       *should* use it for non-trivial projects
 + CMake -- have tried it a bit and have run into problems
   (e.g., multi-job builds failing with frustraing race conditions) 
   with the setups created by others -- but it may be that its not 
   the tool per-se just the use of it
 + have only window-shopped other build systems : Scons, waf, etc.


So, with respect to CMake, I'm mostly sitting on the fence.  I've had a
few less-than-positive experiences with it (have you ever tried to
build VTK from source?) but am not completely turned off by it.  There
is a wonderful tutorial for the autotools:

  http://www.lrde.epita.fr/~adl/autotools.html

but I'm unaware of a similarly helpful (that is, a "this is how you
*ought* to use the tool and here are the main reasons *why*") sort of
tutorial for CMake.

So, what have you folks done to learn about best practices for CMake?

And does CMake have good support for all the needs (esp. the multi- and
cross-language handling) that I listed?

Ed

-- 
Edward H. Hill III, PhD  |  ed at eh3.com  |  http://eh3.com/