Hacker News Reader

Comment by fodkodrasz | Hacker News Reader

Does it support dependency handling between targets, and efficient partial remake of only the changed subtree of the dependency graph? Because what many people miss about make is the support for this, and think it is a way to make "commands" for single level recipies, and auto-complete their names in the shell. A simple shell script would be a trivial solution for that already.

Make does:

- topological sorting based ordering of the dependency tree

- skipping of already up to date targets

- supports parallel execution of independent dependency subtrees

The webpage is totally unclear on this, and to me it looks like it only allows for a named entrypoint to some script snippets.

I'm a literal programming fan though, and this is a nice start, but i recommend clarifying the docs on this.

View on HN

It’s interesting because this is the point of make, but it seems really common for make alternatives to miss this.

And that’s frustrating, because the place where a make alternative could really shine is not in making the syntax for specifying scripts nicer, but in figuring out how to design the dependency APIs so that you aren’t almost guaranteed to get them wrong in subtle ways.

Great point. My take is that most inexperienced people know make only as a bundle of shell scripts with semi-nice unification (not really nice because you just don't have an easy way to pass arguments to your scripts and no automatic help etc.).

Added support for dependency between commands. So one can now write:

    # [clean]() Clean build directory

    ```bash
    rm -rf ./build
    ```    

    # [format]() Format the source code

    ```bash
    npx prettier --write .
    ```

    # [build](clean format) Build the project

    ```bash
    npm run build
    ```

    # [deploy](build) Deploy to surge.sh

    ```bash
    surge ./build my-project.surge.sh
    ```

This doesn't include file time modification between files as in Makefile.

Thank you for feature suggestion.

Make also supports a ton of other features that a lot of people don't use (or don't directly use) or understand.

It's possible to create makefile targets which say "Don't run this other target on my behalf, but if you're going to run it anyway then run it before me"; for example, don't try to create the build output directory every time you run this target, but if it does need to be created then create it first.

Every time I've tried to look for a clean, effective Makefile replacement there have either been obvious (to me) missing features that make anything but the most basic use cases tricky, or the system is so clearly designed to solve one specific problem (e.g. "compile a bunch of .c files into a binary") and as a result is unsuitable for most use cases that Makefiles would be good for.

Reply on news.ycombinator.com