BKSWCMUV.RVW   20060514

"Software Configuration Management Using Vesta", Allan Heydon et al,
2006, 0-387-00229-4, U$59.95
%A   Allan Heydon
%A   Roy Levin roy@Levin.net
%A   Timothy Mann
%A   Yuan Yu
%C   233 Spring St., New York, NY   10013
%D   2006
%G   0-387-00229-4
%I   Springer-Verlag
%O   U$59.95 212-460-1500 800-777-4643 matthew.giannotti@springer.com
%O  http://www.amazon.com/exec/obidos/ASIN/0387002294/robsladesinterne
  http://www.amazon.co.uk/exec/obidos/ASIN/0387002294/robsladesinte-21
%O   http://www.amazon.ca/exec/obidos/ASIN/0387002294/robsladesin03-20
%O   Audience s Tech 3 Writing 1 (see revfaq.htm for explanation)
%P   262 p.
%T   "Software Configuration Management Using Vesta"

The preface tells us that Vesta is a system for version and build
control suitable for projects of all sizes, from the small, to those
large and distributed to such an extent that the standard software
management tools are inadequate.

Part one provides a general description of Vesta.  Chapter one is an
introduction, both to the common versioning (and related debugging and
testing) problems, and to the principles of Vesta: versioning of
source code and tools (with automated handling of relevant object
code), "immortal" storage of all versions, and storage of complete
system model descriptions of all builds and options used in
compilation.  ("Sources," in Vesta, are not limited to source code:
tools introduced into the system are treated in similar ways.  In
addition, immortality is limited to source code: when a derived
entity; one that is built or compiled; is unused for some period it
may be weeded.)  Various development related concepts from UNIX are
listed in chapter two.  The reason for this is not completely clear,
but some of the ideas are used in chapter three, which describes Vesta
at an abstract level.

Part two outlines the view of a Vesta user: the perspective of the
programmer or developer.  Chapter four reviews the management of
versions and sources.  The notion of a name space is similar to the
UNIX file system or the Internet's domain name system (which it
partially uses), with additional linking and restrictions on reuse. 
There is no specific support for merging of changes, in Vesta, but the
tools can be modified to call for a merge utility from another source. 
Chapter five outlines the System Description Language (SDL), a
scripting language for specifying "building" in Vesta.  An example of
the use of the language is given in chapter six.

Part three looks inside Vesta.  Chapter seven examines internal
operations of the repository.  The Vesta evaluator is essentially
responsible for compilation of the software project: chapter eight
reviews the characteristics that allow it to manage complex
development efficiently, reusing as much prior material as possible as
the changes are made incrementally.  The weeder attempts to deal with
the issue of a system that can expand forever on a finite disk: the
algorithms for making the balance between keeping too much (running
out of space) and keeping too little (having too spend to much time
recreating needed parts) are given in chapter nine.

Part four allows us to assess Vesta.  Chapter ten reviews some
competing systems: RCS (Revision Control System), CVS (Concurrent
Versions System, Make, and a few CASE (Computer Aided Software
Engineering) tools.  Performance, in terms of various speeds, memory
loads, and storage requirements, are examined in chapter eleven.  The
data is, unfortunately, not from recent projects that used the system,
but does show that Vesta convincingly outperforms Make, even for
relatively small projects.  (Suggestions are also given for
enhancements to improve the system even further.)  The conclusion, in
chapter twelve, repeats much of the material in the preface.

An appendix provides a reference manual for the SDL.  Vesta is
available as an open source tool at the www.vestasys.org Web site.

The authors admit, in chapter twelve, that there would be a learning
curve involved in persuading developers to use the Vesta programming
environment: Vesta does work in ways that would, initially, be
mysterious to coders familiar with the currently popular tools.  In
addition, there would be some overhead involved in teaching
programmers to use SDL.  (On the other hand, new programmers would
probably take to it quite readily.)

The book is intended as a research report rather than a user manual
(although part two can be used to get started with the system).  Much
of the material concentrates on the internals of the system, and the
aspects that assist in the excellent performance: these operations
will never be seen by the user, although the system response will be
satisfying.  The authors have made no attempt to understand the
information (and writing style) that would be helpful to developers
attempting to use the system, and managers trying to decide whether or
not to implement it.  Open source devotees wanting to understand and
extend the project will find this an invaluable resource.  Researchers
in the fields of software development and system performance will also
find much of interest in these pages.

copyright Robert M. Slade, 2006   BKSWCMUV.RVW   20060514