Redo: A recursive, general-purpose build system

Not impressed by shell incantations. What would sell such a tool to me is a feature to replace those with new and more intuitive syntax. And a terser one, too.

Holding on to how things are done in the shell is not a thing to be proud of. I think a lot of us around here stopped counting the times we got tripped by globbing, forgetting or misplacing one special character in a ${} block, or quoting.

Let those monstrosities die already. Please.

There's this tool -- https://github.com/ejholmes/walk -- that is pretty good and I liked it but dropped it for the same reasons: it leaves the heavy lifting to you and it depends on your mastery in the black arts.

Now obviously I'm not managing huge projects but nowadays https://github.com/casey/just serves me just fine for everything I need.

As an intensive (and reluctant) user of GNU Make, I keep looking for a more modern replacement. Redo is not it.

Make is really a complicated combination of these components:

- a dependency definition language with in-place evaluation and half-assed wildcards

- A functional language with extremely limited datatypes (effectively just space-separated strings)

- a clunky macro system

- A "distributed" topological execution engine (did you know Make can coordinate job slots across recursive executions of Make? It's impressive! And shouldn't have to exist!) [1]

All the alternative build systems wisely choose to tackle only some of these features. Redo is interesting in that it's a minimal system that leans on existing Unix tools to fill the gaps, but I can't say I'm impressed with using Shell as the scripting language, though it is arguably more useful than Make's home-grown language that too few people know. Edit: actually, redo's doesn't enforce Shell, it can be any executable. That's more interesting, maybe (flexibility also introduces complexity!)

The most interesting development in this space is the paper "Build Systems A La Carte" [2] by Mokhov, Mitchell, & Peyton Jones, who did a great job of breaking down build systems to their fundamental concepts, and along the way found one particular point of the design space that wasn't fulfilled (Table 2, p79:16). Unfortunately, I fear it'll be some years before something production-ready emerges from that research, (and I'm sure I'll be grumpy about some of their implementation details anyhow! Build systems do not a happy developer make)

[1] https://www.gnu.org/software/make/manual/html_node/Job-Slots...

[2] https://www.microsoft.com/en-us/research/uploads/prod/2018/0...

I got turned off by the docs when I wanted to try this tool some months ago, maybe it's worth to revisit. Do you recommend it? Do you use it often?

I see GNU Make as sitting on the opposite end of a spectrum than Git. Git is fascinating as a sophisticated, featureful system emerging from a simple fundamental concept (Merkle tree of file hashes), whereas Make is a mish-mash of concepts cobbled together to expose a particular set of user features (describe and execute a graph of executions in a factorized way).

Git emerged decades after other version control systems were first invented, and found a neat abstraction that covered the space.

That's why I have such hope for the BSalC paper and what can emerge from it.

Thanks for the honest take, appreciate it.