GNU Make's got tons of features that aren't in POSIX Make (so does BSD Make).
I use GNU-specific Makefile features all the time - here's a list of some of the cool features:
- Built-in functions (see https://www.gnu.org/software/make/manual/html_node/Functions.html for a list)
- User-supplied functions
- Much better pattern substitution
- Ways to tell Make that some files can be skipped in certain cases (.INTERMEDIATE and .SECONDARY modifiers)
- Ways to adjust Make's behavior (SECONDEXPANSION, DELETE_ON_ERROR, ONESHELL)
As a software packager, I'd advocate for autotools or CMake over a raw Makefile every time (assuming your project is a library or some binaries).
But with that said, I use GNU Make all the time for
"glue automation" - like if I had a folder full of files that needed some processing, I'd probably write a Makefile instead of a shell script. I also use top-level Makefiles on projects that have their own build systems, so that I don't need to remember how they work every time. People use shell scripts for that stuff too, but Make is better IMO.
It annoys me quite a bit when someone decides not to use autotools or meson, or other standard build tools. I have a build system set up to build static packages for several architectures, and most of my packages are described like this:
And it does the right thing for all packages that use autotools.
If you roll out your own Makefile, I have to figure out how to build the targets, how to install them, whether you use DESTDIR, whether you respect cross-compile options, how to build static library, how to configure your package... and code all this by hand to build() function.
The same goes for my custom Arch Linux packages.
Make the packagers job easy and just don't roll your own if you want your package to be distributed widely.
I was so hopeful for cmake in the early days, but have come to be a bit disappointed and avoid it everywhere I can. I shake my head in amazement at the project that spawned cmake (ITK, a medical imaging project) was using Tcl as an embedded scripting language (indeed, one of Tcl’s great features), then faced with needing a scripting language for their build system, decided to ad-hoc build one from scratch. Additionally (perhaps related), as a consumer of software that uses Cmake as its build infrastructure, I do not look fondly on the times I’ve had to debug what’s going on when the promised portability doesn’t work out on my systems. Perhaps it’d also be the same for an autotools build, or sufficiently complex vanilla Makefile, but Cmake does seem to a standout in my mind. This might be because I was so hopeful for it a dozen years ago, but I think the corner cases became too annoying because of their disappointing ad-hoc language, which was an avoidable mistake.
That all said, it’s still clearly managed to be important, and is indeed something the authors can be proud of, though I have personally come to find joy and good success in plain Makefiles.
I understand. In the past I used plain Makefiles too. GNU make is powerful. But it can get unpleasant and unreadably verbose pretty fast.
For personal projects I use either meson, or if they are sufficienlty complex (targetting multiple architectures in a single project and other tricky things) and the environment is known/fixed, I genereate build.ninja file from a PHP based configure script and it's unbeatable as to the flexibility, predictability and build speeds.
The best thing is that I can change anything and I can be sure that the incremental build will be the quickest and the result predictable. No more need for "make clean all" after changing some flags/variables in a Makefile.
It's the benefit meson/ninja combo will give you too, but meson is replaced by an actual well known programming language like PHP in my case.
For known environment builds, it's really nice. Much easier than fishing around the web for random recipies on how to do stuff in m4/meson/autoconf/automake/whatever custom language someone invented.
I really love the intentional simplicity of ninja build.
I use GNU-specific Makefile features all the time - here's a list of some of the cool features:
As a software packager, I'd advocate for autotools or CMake over a raw Makefile every time (assuming your project is a library or some binaries).But with that said, I use GNU Make all the time for "glue automation" - like if I had a folder full of files that needed some processing, I'd probably write a Makefile instead of a shell script. I also use top-level Makefiles on projects that have their own build systems, so that I don't need to remember how they work every time. People use shell scripts for that stuff too, but Make is better IMO.