Archive for March, 2008

End user or development-oriented build system?

Monday, March 24th, 2008

I spent the past three weeks working on Xerces-C++ 3.0.0 which uses automake-based build system. Our own projects here at Code Synthesis all use the build system called build. The work on Xerces-C++ made me realize just how awkward the automake-based build systems are to develop with. It also made me realize that most build systems can be placed into one of the two categories: the ones that are optimized for the end user and the ones that are optimized for development (the Boost build system is a notable exception for it is a pain to use for both end users and, I suspect, the Boost developers).

The primary goal of an end user-oriented build system is to make once-off builds from scratch as straightforward as possible. Because the user can choose to build the software on any platform and installation of additional tools is an inconvenience, the following requirements are imposed on user-oriented build systems:

  • Support for a wide range of platforms
  • Least common denominators in the tools and features used

On the other hand, the primary goal of a development-oriented build system is to make the common development tasks as easy and fast as possible. This translates to the following requirements:

  • Ease of adding/removing files from the build
  • Complete dependency tracking for fast incremental builds

To realize how big a difference a development-oriented build system can make, let’s examine the fairly common development task of implementing a new feature in a library and adding a test for it. Assuming we already made the changes in the library source code as well as added the directory with the new test, here is the list of steps required in an automake-based project:

  1. Add the new test directory into higher-level
  2. Add the new test to
  3. Run the bootstrapping script to generate configure,, etc.
  4. Run configure
  5. Run make in the library source directory to update the library
  6. Run make in the test directory

Instead of the last two steps one can run make in the top-level directory which will update the library, update (at least relink) all the tests and examples and finally run all the tests. In my experience, some people prefer this method because while taking longer it requires less manual work and ensures that everything that the test may depend on is up to date. In contrast, here is the list of steps required in a build-based project:

  1. Add the new test directory into higher-level Makefile
  2. Run make in the test directory

The last step automatically updates the library as well as any other parts of the project on which this test depends and which are out of date.

The steps in the build-based project take hardly one-tenth of the time required by the automake-based project. Someone may say that the task of adding a new test is not very frequent in most projects. Let’s then consider another common task: making a change in the library source code and running a specific test. For automake the list is as follows:

  1. Run make in the library source directory to update the library
  2. Run make in the test directory

As in the previous example, instead of these two steps some people prefer to just run make check from the top-level directory. The equivalent one step for the build-based project is:

  1. Run make in the test directory

The automake steps take at least several times longer to complete and can be much more than that if make is run from the top-level directory. In my experience these delays result in a much smaller number of development iterations I could do on a project as well as reluctance to make changes that are not absolutely necessary (e.g., code quality improvements).

It is clear that the constraints imposed by the two orientations are often incompatible: the development-oriented build system requires powerful tools while the user-oriented one requires us not to depend on anything but the bare minimum.

It is hard to say which build system a project should prefer if the goal is to be successful. On one hand, if the speed of development is restricted to a crawl by the build system, then you are unlikely to produce something worth using in a reasonable time. On the other hand, if potential users are bogged down with numerous build-time dependencies that your project imposes then they are less likely to try it.

Another alternative, which we are using in some of our projects, is to provide two parallel build systems. The obvious drawback of this approach is the need to maintain the two systems. In our case the second build system is only provided for a small sub-set of the project (examples) which helps minimize the negative impact of this approach.

The natural improvement of the two build systems idea is the development-oriented build system that can automatically generate makefiles for the end user build system. Note that this is not the same solution as offered by some build system generators (for example, CMake and MPC) since the overhead of running the generator every time a file is added or removed from the project makes them much less suitable for a development-oriented build system.

Xerces-C++ 3.0.0 beta 1 released

Friday, March 14th, 2008

I’ve spent the past three weeks prepping the Xerces-C++ 3.0.0 code for the upcoming release which culminated in the publishing of the first beta yesterday. The major change in 3.0.0 compared to the 2-series releases is the new, autotools-based build system for Linux/UNIX platforms. Other improvements in 3.0.0 include:

  • Project files for VC 9
  • Support for the ICU transcoder in VC 7.1, 8, and 9 project files
  • libcurl-based net accessor
  • Support for XInclude
  • Support for a subset of XPath
  • Conformance to the final DOM Level 3 interface specification
  • Ability to provide custom DOM memory manager
  • Better 64-bit support
  • Cleaned up error messages
  • Better tested, including against W3C XML Schema test suite
  • Removal of the deprecated code

My primary goals in this release are to make it cleaner, easier to build, better tested, as well as to provide better XML Schema support. And it does feel that the 3.0.0 codebase is on track to achieve these goals. If you are planning to upgrade to 3.0.0 once the final version is out, I suggest that you give this beta a try and report any problems so that they can be fixed before the final release. For more details on this beta see the official announcement.