
Show HN: Task – A simple build tool written in Go - FeatureIncomple
https://taskfile.org/
======
swalladge
> 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/](https://github.com/cblp/yaml-
sucks/)

~~~
dis-sys
> 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.

~~~
snarfy
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.

~~~
convolvatron
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?

~~~
FeatureIncomple
> 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](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.

------
alain_gilbert
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".

~~~
FeatureIncomple
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.

~~~
alain_gilbert
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.

~~~
FeatureIncomple
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?

------
BlackLotus89
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/](https://taskwarrior.org/)

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

------
eknkc
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.

------
cmcginty
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.

~~~
TeddyDD
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](https://github.com/casey/just)

------
ianwalter
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.

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

------
IshKebab
YAML is a terrible choice.

