[f1notformula1]

> That's because people write shitty makefiles.

Which, coincidentally, is my main complaint with Make: It's way too easy to write shitty Makefiles. There are way too many wrong ways to do things. Arguably this is a community problem and not a tool problem, but it doesn't change the fact that most Makefiles are written badly.

I used Make professionally for 5 years and have since moved to other tech stacks that don't require Make but have tools that are far worse in every other way (cough Ant cough). But IMO the reason they win out is they are far less flexible, so there are fewer ways to do things, so they work better in aggregate.

Build tooling is something that most devs look at very rarely, so they never build expertise. Ergo, build tooling shouldn't require expertise.

If my theory holds out, I feel Gradle will become the new Make in a few years or a decade - very powerful but too many wrong ways to do things.

[xyzzy_plugh]

Make is more than 40 years old -- 40 fucking years! And we still use it. It's everywhere. It's not going anywhere. Gradle will not replace it.

Why? Because make works. Because it's actually easy to understand if you've read the manual. It's simple. People try to make it do really complicated things, which you are better off putting in a script or another program. At it's core, make works and does its job very, very well.

Here is a very beautiful, readable, portable makefile: https://github.com/git/git/blob/master/Makefile

It's hard to write portable anything without details leaking out. Go is the best implementation I've ever seen here. It works identically everywhere I've tried it. The approach the Go team has taken is extreme. I think that says a lot.

Both these tools are very simple, and limit what you can do. When you try to go outside the box, you hurt yourself. Don't hurt yourself.

Tools like Gradle make it real easy to hurt yourself without realizing it.

[kazinator]

We don't literally use make, exactly as it was forty years ago.

> Here is a very beautiful, readable, portable makefile: https://github.com/git/git/blob/master/Makefile

That's a GNU Make Makefile. It's portable to installations where you have GNU Make ported already.

[Spivak]

Look, this battle has been lost for ages. People only seem to write portable Makefiles by accident and usually just target the implementation of make on the platform they're developing on.

[vorg]

Unfortunately, when you learn Gradle, you also have to learn its procedural description language, Apache Groovy, with its many quirks, such as when to use

    something "abc"

and when to use

    something = "defg"