Detecting incorrect build rules

  title={Detecting incorrect build rules},
  author={N{\'a}ndor Licker and Andrew C. Rice},
Automated build systems are routinely used by software engineers to minimize the number of objects that need to be recompiled after incremental changes to the source files of a project. In order to achieve efficient and correct builds, developers must provide the build tools with dependency information between the files and modules of a project, usually expressed in a macro language specific to each build tool. Most build systems offer good support for well-known languages and compilers, but as… 

Figures and Tables from this paper

A model for detecting faults in build specifications
This work presents BuildFS, a generally-applicable model that takes into account the specification of build executions and the actual behavior (low-level file system operation) of build operations, and is the first to handle JVM-oriented build systems.
Identifying Bugs in Make and JVM-Oriented Builds
This work presents buildfs, a generally-applicable model that takes into account the specification (as declared in build scripts) and the actual behavior (low-level file system operation) of build operations, and is the first to handle Java-oriented build systems.
Build scripts with perfect dependencies
This work outlines a build system where dependencies are not specified, but instead captured by tracing execution, and the consequence is that dependencies are always correct by construction and build scripts are easier to write.
Root Cause Localization for Unreproducible Builds via Causality Analysis Over System Call Tracing
RepTrace is proposed, a framework that leverages the uniform interfaces of system call tracing for monitoring executed build commands in diverse build environments and identifies the root causes for unreproducible builds by analyzing the system call traces of the executedBuild commands.
Forward build systems, formally
This paper defines what it means for a forward build system to be correct, and shows that other forward build systems, such as Fabricate and Memoize, are also correct.


Automated migration of build scripts using dynamic analysis and search-based refactoring
This work proposes the first dynamic approach for automated migration of build scripts to new build systems and implemented the proposed two phase migration approach in a tool called METAMORPHOSIS that has been recently used at Microsoft.
An empirical study of build maintenance effort
Analysis of the version histories of one proprietary and nine open source projects of different sizes and domain to analyze the overhead that build maintenance imposes on developers indicates that, despite the difference in scale, the build system churn rate is comparable to that of the source code.
Design recovery and maintenance of build systems
The design and implementation of a re(verse)-engineering framework for build systems named MAKAO is presented, which makes the build's dependency graph available in a tangible way and enables powerful querying of all build-related data.
Fault localization for build code errors in makefiles
This work introduces MkFault, a tool to localize errors resulting in build crashes by monitoring the execution traces from GNU Make statements that produce concrete build rules and the original code locations for each component of a rule.
A qualitative analysis of software build system changes and build ownership styles
This paper qualitatively investigates the build commit history of 18 open-source projects from the Apache and Eclipse eco-systems, over a period of fourteen months, using manual tagging and classification of change types and build system ownership styles.
The evolution of ANT build systems
This paper studies the evolution of ANT build systems from two perspectives: a static perspective, where the build system specifications are examined using software metrics adopted from the source code domain; and a dynamic perspective where representative sample build runs are conducted and their output logs are analyzed.
The Evolution of the Linux Build System
This paper takes a look at the phenomenon of evolutionary changes on the software's build system in the Linux kernel from its inception up until present day by analysing the kernel's build traces with MAKAO, the re(verse)-engineering framework for build systems.
Apache Maven
Maven is a software tool for Java project management and build automation that comes with pre-defined targets for performing certain well defined tasks such as compilation of code and its packaging.
Formalizing and Verifying a Modern Build Language
This paper formally and mechanically verifies the correctness of central CloudMake algorithms with formalization and proofs done entirely in Dafny, the proof engine of which is an SMT-based program verifier.
Recursive Make Considered Harmful
This paper explores a number of problems regarding the use of recursive make, and shows that they are all symptoms of the same problem, and the problem stems from the artificial partitioning of the build into separate subsets.