8 ms·
Tup – an instrumenting file-based build system
- junon 4y agoI used to use this _extensively_ years ago. It sounds great in theory but very quickly gets in your way.
- pxc 4y agoWhy was it chosen and why did you regret that choice? Could you explain a bit more?
- junon 4y agoI wanted something faster than Make that was cross platform, that let me also define my own processes instead of needing high level "language aware" build systems. Tup fit nicely, until build variants or Java were needed. Aside from not really working well on Windows, at least at the time, variants were completely broken on Windows. Further, compiling any Java with inner classes was impossible since they emitted extra class files for each inner class, which meant the build artifact hierarchy depended on the code - something Tup isn't prepared to handle. It just got really annoying over time. Ninja-based systems quickly replaced it for me.
- agumonkey 4y agoI wonder if tup devs are aware and interested in adapting their model to solve the multiple byproduct per file.
- gonzus 4y agoLast time I dabbled with tup, I remember it was not trivial to support any process that generated more than one output. My use case back then was lex / yacc: you can generate a source and a header file with them (and even some other output files), but it was not trivial to capture these dependencies with tup.
- rcthompson 4y agoA while back I went through several of these kinds of build systems. The one I eventually settled on was Snakemake[1], with which I finally was able to put together an entire complex bioinformatics workflow[2]. I would say that Snakemake's strength is one of Perl's old mottos: "making easy things easy and hard things possible." On the easy side, writing a simple rule with fixed inputs and outputs is just as easy as Make (trading the weird whitespace rules of Make for the less weird whitespace rules of Python). On the hard side, it supports stuff like computing inputs at runtime, or using regex capture groups to determine output file names from input file names. So for example you can have your rule for LaTeX to PDF conversion read the source TeX file, determine all the external images, bib files, etc. referenced from it, and add those files as input dependencies so that when any of them changes, Snakemake will know to rebuild the PDF. See e.g. this rule[3] that builds my resume PDF from the LyX source. [1]: https://snakemake.readthedocs.io/en/stable/ https://snakemake.readthedocs.io/en/stable/ [2]: https://github.com/DarwinAwardWinner/CD4-csaw https://github.com/DarwinAwardWinner/CD4-csaw [3]: https://github.com/DarwinAwardWinner/resume/blob/main/Snakefile#L169-L175 https://github.com/DarwinAwardWinner/resume/blob/main/Snakef...
- nerdponx 4y agoI really tried my best to use Snakemake in ~2018-2019 for day-to-day data science work. I found that its DSL was a confusing and (at least at the time) under-documented hybrid of Python and custom syntax. It also suffered from some of of the primary limitations of traditional Make: • Targets/outputs must be files, without even the opportunity to extend the space of possible targets e.g. using your own hash comparison function. This is not suitable for a workflow where the output is a directory of filenames that aren't known in advance, or a database table. • By default, can only run commands through a shell, not directly as a subprocess. At the same time, it also lacks support for nontrivial chaining and composition of commands. In your CD4 example you hack around this by literally writing your own pipelining command runner in Python; hard to say if that's any better than a big blob of shell script in a string! I agree that it definitely "makes hard things possible", but my experience did not give me the impression that it "makes easy things easy". It was frustratingly deficient in what I believe are obvious areas for improvement, and some of the most obnoxious Make pain points that I encounter on a regular basis, even for regular day-to-day software development. I ended up switching from Snakemake to DVC basically as soon as it came out, because it at least supports using directories as outputs, and has a few other nice features that specifically work well for data science project version control and artifact management/sharing for collaboration. That said, I had/have much less of a need for complicated workflow orchestration than for easy tracking & sharing of datasets and large artifacts (fitted models, processed tabular datasets), and for tracking directories as outputs (partitioned Parquet datasets). It would be interesting to go back and re-evaluate the space of workflow DSLs and task runners, because DVC does not have the complete feature set that Snakemake has, and IMO nor should it (I am already getting worried about its feature creep). I'm also not sure if or how well Snakemake and DVC could be made to work together; the former for task running and the latter for task input/output tracking with version control. The perfect tool (or better yet, the perfect combination of tools) remains elusive.
- deleted 4y ago[deleted]
- aidenn0 4y agoI spent a lot of time exploring make replacements a while back. I really like Tup as a "update outputs based on inputs" system. A lot of people get hungup on it though because there are things that make can do that Tup can't, as Tup is much more of a special-purpose tool than Make. "make install" for example is specifically something Tup can't do. This is trivially solved by having "install.sh" There are also various limitations, caveats, &c. such that I typically had a "build.sh" or some-such that did any necessary pre-tup work. The most restrictive rule is the set of output pathnames cannot depend on the contents of input files; they must be fully realizable from just the set of input pathnames. Calculating this outside of tup is fine even if it's expensive, as long as it changes rarely. Tup will error if the list is wrong, so you can't accidentally build with out-of-date outputs.
- majewsky 4y ago> "make install" for example is specifically something Tup can't do. This is trivially solved by having "install.sh". `make` is different things to different people. What you describe, `make` as a tool to compute optimal strategies for recursive file-based build operations, is indeed its original purpose. On the other hand, I tend to use `make` more as a standardized format for script collections. Whenever I open a new repository, and it has a Makefile in it, I'm very thankful because it's a useful jumping-off point for how to build and use the software contained in the repository. Therefore I do the same in my own projects. Even if the project is in a single language with established conventions, I tend to include a Makefile regardless as a way of documenting. For example, if I have a Go project, I could rely on other people looking into it to know how Go is compiled, or I can just put in a little Makefile like: PREFIX = /usr build/foo: go build -ldflags '-s -w' -o $@ ./cmd/foo install: build/foo install -D -m 0755 build/foo "$(DESTDIR)$(PREFIX)/bin/foo" .PHONY: build/foo install Which will make it entirely obvious to everyone, including non-Go-developers, how to build and install the software.
- aidenn0 4y agoSee my comment to a sibling post, but I originally had something just like that with "tup" rather than "go build" but people complained so I switched it to "build.sh" and "install.sh" and people stopped complaining.
- xvilka 4y agoKolibriOS[1][2] uses it as a primary build system. [1] https://kolibrios.org https://kolibrios.org [2] http://websvn.kolibrios.org/listing.php?repname=Kolibri+OS http://websvn.kolibrios.org/listing.php?repname=Kolibri+OS
- jmiskovic 4y agoOn one project that supports both tup and cmake: building from scratch with tup takes 8 seconds, ninja takes 18s and "make -j" takes 22s. If you are a heavy shell user you'll also appreciate that tup can be executed from any subdir within the project, no need to keep around extra terminal just for compiling.
- kazinator 4y agoThat means that the upper bound on doing nothing but compiling the stuff is 8s. to which make adds 14s of pure waste. That's a weird situation which seems like having a low probability of being broadly representative.
- drothlis 4y agoYeah, meaningful benchmarks take a lot of work. - Does the reported ninja time include the cmake step that generates the ninja files? (which typically doesn't need to be done for incremental builds). - "make -j" doesn't limit the number of jobs, so you can run into resource contention if building too many things at once. Ninja (by default) limits the parallel jobs to the number of CPUs. - Disabling make's built-in rules (with `-r -R`) can make a big difference to performance. - Make spends a lot of time processing the ".d" files with header dependency information -- 98% of the time in my (artificial) benchmarks!
- jmiskovic 4y agoThis wasn't a "meaningful benchmark", just a single data point to show how tup makes practical sense, when everyone else was criticizing "yet another build system" on theoretical points. I included the time to generate ninja files, the measured time is for project to build from scratch. Tup generates its initial files _much_ faster (~0.2 seconds compared to ~4 seconds). The strength of tup is actually in incremental builds, but that's harder to measure: you get shorter times with larger relative variations between repeated tries. I wasn't interested in working around the bad make defaults, I also didn't spend any time optimizing tup flags.
- 4y ago
- 414owen 4y agoI migrated my main personal project (a programming language written in C) to Tup recently. So far I love it, it seems to 'just work'. Some highlights: No need to map header (or other) files to C files. Tup detects when files are read and adds them as implicit dependencies. Environment variables (that are used) are considered build inputs, so no need to `make clean` when you need a build with debug symbols. --- Admittedly my project is quite straightforward, but I thoroughly recommend giving Tup a try.
- ki_ 4y agonice, my biggest problem with c is macros and how to build something. Make files are freaking horrible, tup seems like a nice alternative that keeps it simple. Simplicity is important. Complexity is the result of bad design.
- dkersten 4y agoI’ve been using it for personal C++ projects for a few years (because I despise CMake) and find it quite pleasant. You do have to do things it’s way, though. Don’t expect it do adapt to your structure, you may need to rethink things slightly. Also don’t expect it to be a one stop build tool, I still use a simple makefile and “make init” to build dependencies that need to be compiled with something other than Tup, and then use Tup only to build my own sources.
- drothlis 4y agoTup has some automated performance tests, which I co-opted to benchmark Ninja vs. Make: https://david.rothlis.net/ninja-benchmark/ https://david.rothlis.net/ninja-benchmark/
- drothlis 4y agoSee also gittup, an experimental linux distro where the entire linux kernel + userspace is built using tup. https://gittup.org/gittup/ https://gittup.org/gittup/
- dlahoda 4y agois it like nix?