Why You Should be Using Vesta
"make was a really good project for a college student [to implement] 20 years ago."
-- Tim Leonard, Intel Massachusetts Microprocessor Design Center
If you're wondering why anyone would chose Vesta over other alternatives (e.g. CVS+make), here's a summary of some of the reasons that Vesta users find most compelling.
Automatic dependency detection. It's complete, precise, fine-grained, and language-independent. Even dependencies on the compiler version, compiler and linker command line options, and system libraries are recorded. The user never needs to even think about dependencies, and can't cause problems with incorrect ones. You don't need help from a hack like makedepend. Dependencies aren't based on time-stamps, so you don't have to worry about clock skew or partially-written result files.
User-independent builds. Builds take place in an encapsulated environment. The user can't make or break a build with their personal environment or other settings.
Guaranteed repeatability of builds. Builds completely specify everything that affects their outcome, including the exact versions of all source files, as well as compiler versions, library versions, etc. This makes it possible to perform any build you've ever done in the past and be certain that you will get identical results. (This can be a big help with finding and fixing bugs and other QA issues; with Vesta you never have to worry that a bug has been masked rather than fixed by intervening changes, because you can always re-build the exact version that exhibited the problem.)
Collaboration features. The Vesta replicator makes it easy to share source versions, and even complete builds between different installations. Also, the guarantee of precise repeatability is maintained even when a build is performed at a remote site from a replica. The repository user-interface tools are designed for collaboration with remote repositories: the checkout and tool can automatically get a local working copy of a remote package (assuming you have permission), and the checkin tool will replicate the checked in version back to the remote master repository.
File-system interface to the repository. All versions are accessible through a file-system which users can access with all the normal tools they're used to. It's simple to grep across versions, diff between them, and use Emacs' ediff and other sophisticated conflict resolution tools. (More creative users can write complex scripts to take advantage of this.)
Shared cache of build results. Thanks to automatic dependency detection and the user-independence of builds, there's no problem with sharing build results between users. The build work done by every developer is "remembered"in a per-site Vesta cache. Since the cache is shared by all developers at the same site, each can benefit from the work done by the others' builds.
It's high-performance. The Vesta builder is faster than make. It can run with multiple threads, and even execute compilers and other tools on multiple hosts simultaneously. (This can increase build throughput significantly, making developers more productive.) Checkout operations are constant-time, because the repository stores a complete copy of each source file. There's no latency for copying on checkout or checkin, because working copies are managed by the repository file-system. No storage is consumed by a checkout until the user saves changes to a source file, because the repository uses copy-on-write for working copies. (See chapter 9 of the research report for more details on Vesta's performance.)
It's free. Vesta is distributed free of charge under the terms of the GNU Lesser General Public License.
It's extensible. The command-line tools make it easy to write scripts that perform complex operations. Vesta's flexible attribute system makes it possible to associate all manner of meta-information with the repository's contents. With the C++ APIs, one can build high-performance extensions or write new tools to perform operations which the existing tools don't. (And since Vesta is distributed under the LGPL, extensions are not forced to adopt the same licensing terms.)
It's mature. Vesta has had over 10 years of research and development, and over 5 years of real-world use by a very demanding group. It's well-tested, stable, scalable, and designed from the ground up to be fault-tolerant. It was designed specifically to overcome the limitations of existing systems, and is competitive with several commercial offerings.