> you just need to describe your build tasks using a simple YAML schema

I don't understand this. How is it easier/nicer to learn an arbitrary schema in an ambiguous[1] data serialization language than the makefile syntax which was designed specifically for the purpose?

I'm not criticising the project; I'm sure a lot of work has gone into it and it is decent software. But I wouldn't encourage people to be quick to disregard 'difficult' mature software and jump at something new that makes claims about being 'simple and easy'.

[1]: https://github.com/cblp/yaml-sucks/

> the makefile syntax which was designed specifically for the purpose?

and proven by generations of programmers.

the (very sad) problem here is that for some people makefile is not trendy, it is something first released 42 years ago.

As someone who's been using makefiles for about 30 of those years, I have to say make sucks. It's barely evolved at all. There is a reason there are so many alternatives to it, and it's not be because it's trendy. I mean, you can't even copy a file with it. That takes an external program.

it does. unfortunately its still the one i reach for because it never seems like a good time to research alternatives.

generally the tools that are optimized to make the common case easy aren't so useful to me because i often have alot of intermediate build artifacts/stages.

and i really like the declarative nature of make..just not all the fragility and warts.

does anyone have any suggestions for a nice general declarative alternative?

> I often have a lot of intermediate build artifacts/stages

I don't know your use case in depth, but I don't see why Task wouldn't work for you, since it's similar to Make in this regard.

You can have multiple tasks (for each step) and then either set dependencies or have a task that call all other tasks in the right sequence. And, of course, you'd have to enable [this](https://taskfile.org/#/usage?id=prevent-unnecessary-work).

Anyway, seems that Make is already enough for you, since you're used to it's quirks.

It's not solely about syntax.

Have you tried using Make on Windows? I know, I also prefer Unix-like systems over Windows (and I barely use Windows these days anymore), but for those that need Windows support, it's a miserable experience trying to use tools that barely work there.

Checksum based (instead of timestamp based) up-to-date resolution is also nice. Etc, etc.

In short, I don't think Task is perfect (far from it), but we desperately need better alternatives to Make.

Oh wow, I didn't tried it yet, but reading the doc, it looks exactly how I imagine the perfect "make"/"task runner" should work.

"make" frustrated me so many times. I'll definitely try "task".

Take a look at Tup, too.

http://gittup.org/tup/

Thanks for these words!

Although I don't think this tool is perfect, I created Task exactly due my frustration with Make and the lack of decent alternatives.

Let me know if you any feedback after you try it.

After giving a quick look, my tasks are twice faster with make.

So I was curious to know why and I tried to clone the project to debug it, and could not figure out how to setup the dependencies properly.

You should add a section how to contribute/develop.

Yeah, a contributing guide would be nice. Thanks for the suggestion.

I'm curious on why Make runs twice faster to you, since in most cases the difference should be negligible (i.e. the Task overhead should be insignificant compared to the time it takes to run the command).

Maybe you're running really lightweight, like `cp`? Otherwise I'd consider it a bug. Could you open an issue, then?

This project does look cool, I'll probably give it a whirl too.

If you're open to ruby, rake is an awesome and powerful tool that is a ruby DSL implementation of make. Learning rake was one of the best investments I made. Even tho I'm a polyglot these days, I still often use rake, even tho it does make some golang people vomit :-)

https://github.com/ruby/rake

> I still often use rake, even tho it does make some golang people vomit

LOL.

I love both Go and Ruby. Each of them shines on different scenarios.

Meh I hate generic names like this, especially if they are taken already. For instance taskwarrior uses the task binary as well.

Have to take a look at it nonetheless

https://taskwarrior.org/

The name was throwing me off. Thought it was relating to TaskWarrior at first.

I’ve been using Task on multiple projects for a couple of months now. Initially I whated to be able to easily create some deployment config files using it’s templating features. Worked great. Now I just default to task instead of make on new stuff.

Please forgive me, but how is this easier to use than make? I see a lot of these "reimplement tool X in language Y" projects, but what is the point if it's not actually solving the problem better. Just looking at the link it seems to resemble Ant which also started with similar design goals.

I'm not sure about task but I use Just [1] - it's similar program. It's nice way to collect commands you often run in given project.

Make is build system, with strong focus on building C program. It has clunky syntax and many quirks. Just is just taks runner ;)

[1]: https://github.com/casey/just

Used this for a project about a year ago and it was great. There was room for improvement, but it did what we needed it to do without any fuss.

I've been putting off setting up a makefile for my project. I'll give this a go

YAML is a terrible choice.