Inadequate build systems can dramatically impact developer productivity. Bad dependencies, false compile errors, failed software images, slow compilation, and time-wasting manual processes are just some of the byproducts of a subpar build system. In Software Build Systems, software productivity expert Peter Smith shows you how to implement build systems that overcome all these problems, so you can deliver reliable software more rapidly, at lower cost.
Smith explains the core principles underlying highly efficient build systems, surveying both system features and usage scenarios. Next, he encapsulates years of experience in creating and maintaining diverse build systems–helping you make well-informed choices about tools and practices, and avoid common traps and pitfalls. Throughout, he shares a wide range of practical examples and lessons from multiple environments, including Java, C++, C, and C#. Coverage includes:
Mastering build system concepts, including source trees, build tools, and compilation tools
Comparing five leading build tools: GNU Make, Ant, SCons, CMake, and the Eclipse IDE’s integrated build features
Ensuring accurate dependency checking and efficient incremental compilation
Using metadata to assist debugging, profiling, and source code documentation
Packaging software for installation on your target machine
Best practices for managing complex version-control systems, build machines, and compilation tools
If you're a developer, this book will illuminate the issues involved in building and maintaining the build system that's best for your team. If you're a manager, you'll discover how to evaluate your team's build system and improve its effectiveness. And if you’re a build "guru," you'll learn how to optimize the performance and scalability of your build system, no matter how demanding your requirements are.
Review By: Scott McMaster 10/19/2011Software Build Systems by Peter Smith seeks to provide guidance for choosing, setting up, and managing software builds. Smith is primarily concerned with C/C++, Java, and C# builds. There is little discussion of build-system issues specifically relating to web applications.
The book is divided into four parts. Part 1 discusses basic concepts of a build system and gives a simple example using GNU Make. Part 2 is a survey of a number of popular build tools, including GNU Make, Ant, SCons, CMake, and Eclipse. Parts 3 and 4 (about one third of the book) expand into a wide variety of topics including dependencies, version management, and controlling complexity and optimizing large builds.
Readers may find parts 1 and 2 to be only of marginal use. The intent of the build-tool survey seems to be to illustrate different approaches and certain principles of building. Unfortunately, the principles get lost in the details of the individual tools. There are several sections that seem out of place in a book on build systems and unfortunately distract from the main presentation, including introductory Python material (relating to SCons) and some extremely basic Eclipse facts (including ample screenshots that are likely to become out of date). These combine to make parts 1 and 2 overly long at about 300 pages. And yet, none of the surveyed tools is discussed in enough depth to be of much help in starting or maintaining a non-trivial build process. Doing that would require obtaining additional resources on your tool of choice.
Parts 3 and 4 are much closer to what the "Principles and Experience" subtitle might suggest, including chapters on dependencies, managing build size, and speeding up builds. A large body of wisdom is distilled into a single chapter on reducing complexity, with immediately usable tips and best practices like not allowing the build system to invoke the version control system and not controlling the build with environment variables. The material on building and integrating with components is particularly interesting.
An experienced build engineer probably would not find this book useful, as most of the material is quite basic. Software Build Systems is best suited for developers and testers who are unfamiliar with build systems but wish to apply additional rigor to their existing processes.