Inspiration and References

Build systems

Fix is heavily inspired by djb’s redo, which has been a source of inspiration for many others as well. – I’ve tried to learn from all of the implementations I could find, so it’s not more than fair that I try to list them here. The list is in chronological order, and dates are the first date of activity I could find for each project (date of first git commit, unless explicitly stated).

• djb redo (by Daniel J. Bernstein) – Unimplemented. In 2003 Bernstein wrote a series of notes on a hypothetical build system of his own devising. He never publicly released any code, but his insightful comments inspired many others. (October 13, 2003 – date from WayBackMachine)

• Grosskurth redo (by Alan Grosskurth) – Written in Bourne Shell. Grosskurth wrote a his 2007 master’s thesis, Purely top-down software rebuilding, on redo. The thesis included simple implementations of the redo commands described by Bernstein (redo, redo-ifcreate and redo-ifchange). He also held a presentation, “Reliable Software Rebuilding,” in which he discussed some of the ideas. (April 10, 2006 – date from slides)

• tup (GitHub) (by Mike Shal) – Written in C. Tup seems not to have been inspired by redo at all, but offers a independent take on the top-down building tool. The main focus of tup is speed and correctness of build (when build rules are removed, the corresponding target files are automatically removed; eliminating the need for clean builds). Tup, just like Make, uses a single buildscript with its own quirky syntax. Shal wrote a paper on tup called Build System Rules and Algorithms. (February 16, 2008)

• Apenwarr redo (by Avery Pennarun) – Written in Python. Well documented and feature-rich, this implements parallel builds, and other improvements on top of redo. Usually when I find that I want to refresh my knowledge about some particular detail of redo I go to Apenwarr’s excellent documentation. (November 12, 2010)

• credo (by Jason Catena) – Written in Inferno SH. This is a slightly different take on redo (for one, the commands does not start with the expected credo- prefix, and build metadata is written in the target directory, cluttering, but also creating an interface for higher-level build tools). (June 15, 2012)

• Pollard redo (by Jonathan de Boyne Pollard) – Written in C. A small reimplementation of Grosskurth redo (with no extra features, but fixing the problems Grosskurth himself noted in his thesis). Pollard also wrote an excellent analysis, “Introduction to Redo”, describing some of the problems with the redo design and the Apenwarr implementation in particular. (November 4, 2012 – date from web page HTTP header)

• Jekor redo (by Chris Forno) – Written on-camera in Haskell, with the videos of him writing the code available on YouTube. It is written as an introduction to programming in Haskell, and is not the most feature rich version of redo out there, however, it is instructive to listen to Jekor’s reasoning while he’s writing it. (March 31, 2013)

• gup (by Tim Cuthbertson) – Written in Python. Gup solves a problem in the redo design (wherein redo to silently fails to rebuild its targets if build metadata is lost). Since the fix breaks compatibility with redo, this tool is called 'gup' instead. See: “Announcing the gup build tool.” (November 2, 2013)

• Moskopp redo (by Nils Dagsson Moskopp) – Written in Bourne Shell. Moskopp has reimplemented the redo envisioned by Apenwarr, but done so using only tools on GNU Core Utilities or BusyBox, thereby speeding up dependency checks, and minimizing the software that needs to be installed. (2014)

Articles

Apart from the above implementations of build systems, I have found inspiration in a few articles and blog posts critiquing, reviewing or commenting on those, and other, build systems.

Note also that Bernstein, Grosskurth, Shal and Pollard (above) all include detailed articles explaining the workings of their implementations. The have been omitted below for brevity.

• A quick introduction to redo (by pozorvlak) – A introduction to Apenwarr redo, presented at the Glasgow.pm Tech Talk. (January 14, 2011)

• Redo from Scratch (by pozorvlak) – Starting off by saing ‘I think that djb redo will turn out to be the Git of build systems’ pozorvlak goes on to talk about the obstacles redo faces in order to become ‘the git of build systems.’ (January 12, 2011)

• Four Interesting Build Tools (by Neil Mitchell) – A brief informative and inspiring overview of the four build tools redo, ninja, tup and fabricate, summing up their respective approaches and weighing the pros and cons of each. (February 28, 2012)

• Falsehoods Programmers Believe About Build Systems (by pozorvlak) – A list of interesting points to any designer, or implementer of a build system. (December 6, 2012)

• Scalable Build Systems: An Analysis of Tup (by Chad Austin) – A detailed analysis of Tup, and comparison to the author’s own build system ibb. (June 10, 2010)