tup

If your system is C based, tup [0] fulfills your request by watching the outputs of the specified commands. It isn't, however, appropriate for systems like java that create intermediate files that the developer didn't write [1]. [0] https://gittup.org/tup/ex_a_first_tupfile.html [1] https://github.com/gittup/tup/issues/113 Back to bazel, I am of the impression that some of its complexity comes from a requirement to handle heterogeneous build systems. For example, some python development requires resolving both python dependencies and C. Being good at either is a bunch of work; but, handling both means rolling your own polyglot system or coordinating both as a second class citizen.

The tup[1] build system also uses ldpreload injection as an aspect of its (additionally(?) FUSE-based) dependency-specification enforcement. 1: https://github.com/gittup/tup/blob/master/src/ldpreload/ldpr...

The sandboxing restriction is one that merits care for (or not supporting) some use cases. Tup requires declaring all outputs (but not all inputs), which can be inconvenient when a build process creates intermediate or derived files that are tedious to anticipate. [0] [0] https://groups.google.com/g/tup-users/c/umW73zR5JKc?pli=1 . ex java creates numbered .class files for anonymous classes declared in a larger java file. In fairness, while looking, they may have relaxed some of that since I last looked with a transient flag https://github.com/gittup/tup/issues/405

Please someone mention Tup and how it can be a reasonable build system. I’ve heard the Fuse dependency is not ideal, though I felt it had a nice UX experience with the Lua config. Plus it’s worth considering that you can potentially use Fennel to configure the builds (since Fennel compiles to Lua). Tup: https://github.com/gittup/tup Fennel: https://fennel-lang.org/

I think tup used to use LD_PRELOAD and seems to still support it: https://github.com/gittup/tup/issues/394#issuecomment-636378...

In fact it is: sqlite3 .tup/db 'select name from node where type=4' | xargs echo rm -f [1]: https://github.com/gittup/tup/issues/120#issuecomment-64832104

It's extremely unlikely that Tup provides a "clean" command. They've expressed a philosophical opposition to it on a few occasions: https://github.com/gittup/tup/issues/120 They're make a really clear distinction between a build system, and a build support system. The "clean" command falls into build support, and the Tup team would argue this is better served with techniques like "git clean -xdf" The "make clean" command is not perfect. Even if someone writes this make phase correctly, it may break after you sync new makefile changes on a dirty project dir. What do you do in that case?

Not sure whether it has a FUSE dependency any more.[0] Code says: TUP_MONITOR = inotify [0] https://github.com/gittup/tup/blob/master/linux.tup

I'd not heard of tup, thought I'd try it out on Windows. Unfortunately I hit a bug straight away: Tup is not directly compatible with MSVC 2015 (without disabling VCToolsTelemetry.dat generation in the registry) [0]. I don't fancy adopting a tool that forces me to opt-out of being able to send compiler debug telemetry to Microsoft the next time I hit a compiler bug. There is a nice (but a bit dated, 2010) review here [1] which discusses some other features and shortcomings. [0] https://github.com/gittup/tup/issues/182 [1] 2010: https://chadaustin.me/2010/06/scalable-build-systems-an-anal...

> Reproducible builds are useful for purposes other than security, though. I've been using an off-the-wall build system called Tup [0], which is designed to support optimally fast incremental builds (i.e. build times that don't scale with the codebase), and it calls for some of the same constraints, chiefly, a strictly deterministic build (no timestamps, control access to environment variables and all file IO). It even deletes generated files when they leave the graph for any reason (being philosophically opposed to a "clean" target). It's an opinionated tool, but it does deliver on its promise. The author also maintains (or at least used to maintain) a Linux repo/distro that is somewhat in the spirit of the OP, at least to the extent that git implements a kind of blockchain.[1] So yeah, there's considerable overlap between this and pro

I love Tup, it basically replaced Make for me. It tracks dependencies and files, automatically cleaning and updating everything even more precisely than Make, making it a lot faster and easier to use. https://github.com/gittup/tup (yes, you can use Tupfiles in each directory, if that's what you mean by packages. As far as I know however, (and this is by design) there is no way to control the build. It will always build exactly what needs to be built to be up to date.)