Other build tools have a steeper learning curve. If they're more complex than the problem being solved, people won't want to adopt them.
When things get complex, there's the GNU make manual and libraries.
When you have to target multiple platforms, there's autotools, which is really complex and intimidating, but less complex than targeting multiple platforms.
Alternatives to make seem to fit in between make and autotools.
Make sucks. I've also heard that Unix sucks, and C sucks, too. Despite this alleged suckyness, these things not only persist, but accumulate improvements over the years.
I really don’t like Make for the common use-cases it is being used for in the modern day, such as the Golang ecosystem or in many cases: creating docker files.
Make, at its core, is a tool that is meant to help you structure your dependencies for incrementally building things, but people use it as a glorified task runner simply due to the fact that it’s such a common build tool that it is nearly always installed if you have a development toolchain on your machine.
Go and docker already have incremental compilation built in, and docker doesn’t give definable artifacts so you can’t make other things depend on them either
It is a powerful tool, but the syntax is hideous and has more jagged edges than bash does, and we aren’t even using it in a way that justifies this. Makes me so frustrated for some reason.
Like everyone deciding to use a supercar to do farmwork.
To tell the truth, make sucks incredibly for building modern C programs. There are just too many targets. It's why all of them generate their makefile with some abomination.
Make works remarkably well. You’re just confusing it with C compilation. None of these complaints have anything to do with make.
Autotools, which generate configure scripts, was built to work around the specific issues associated with old-school C cross platform compilation (with shared libraries, version differences, and misc libc editions). Ditto valgrind, et.al.
So, yeah. Make’s fine. You just don’t like C. Which, that’s cool, just unrelated.
Make is only bad under the Autotools mess. Every build-related struggle in an open-source project that uses Autotools can be traced to Autotools, not to make.
Autotools wasn't invented to overcome deficiencies in make, but deficiencies in C portability across Unix flavors.
Those deficiencies are greatly diminished today, both by POSIX standardization, and there being fewer viable surviving Unix variants that anyone cares to build for.
I've worked professionally for 17 years and have literally never worked on a project that used makefiles or even CMake. Said projects have mostly been cross-platform across Windows, mac, Linux, Android, iOS, and a wide variety of video game consoles.
Autotools and makefiles are the worst solution for running builds... period. Building/compiling for Linux is soooo much worse than literally every other platform. It's stuck in the 70s.
I have a problem with make. It's super slow. And impossible to get right. Autotools is awful but better than hand-edited Makefiles. CMake is far far better than either of the previously mentioned options.
C, as a cross-platform language is fine...but, make on different platforms gets really ugly. It's not terrible across the modern Open Source platforms, like Linux and FreeBSD (and there's pretty good doc coverage of building compatible makefiles or using GNU autotools), but on systems that don't have the GNU autotools, and have a proprietary make, it can be incredibly painful to deal with.
It's been a few years since I dealt with distributing C across many platforms, but I can't imagine it's changed dramatically for the better (since make has been famously painful for about as long as it has existed).
Most of the common criticisms of Make are actually criticisms of autoconf, which I agree is a hideous tool. (On the other hand, autoconf is a tool intended to address a hideous problem, so perhaps that's inevitable).
A lot of the more recent build tools I see are largely reinventions of Make. Make is very widely supported (most basic projects can make do[0] with portable Makefiles, though GNU Make is also available for most systems), and its syntax is actually very easy to grasp and manipulate[1].
[0] no pun intended
[1] Most projects only need a very small subset of what Make has to offer, anyway, and that can be learned in a matter of minutes.
Yeah. There is a metric crap-ton of the design of Make that is solely for the purpose of compiling and linking and document processing. That's actually part of what makes it annoying to use it for projects other than C or C++, when you don't need to compile or transform or depend on different formats.
Make has a branding problem. Most people consider it a build tool for C programs when it's actually a declarative language for defining relationships between files. It's been a viable tool for decades (talk about a mature product!) because of its power and flexibility. And no build tool matches its wonderful accessibility, since you can just drop arbitrary shell commands in your recipes.
Compared to the autotools I'd say make is fairly decent! But yeah, it's a mess. I wonder if it's really possible to improve significantly over the status quo if you're not willing to compromise on flexibility and design the build system alongside the language itself, like Rust does with cargo for instance.
Make on the other hand is completely language agnostic, you can use it to compile C, Java, LaTeX, or make your taxes. Make is a bit like shell scripts, it's great when you have a small project and you just want to build a few C files for instance[1] but when it starts growing there always comes a point where it becomes hell.
[1] And even then if you want to do it right you need compiler support to figure header dependencies out, like GCC's various -M flags.
Make shares a fundamental property with C and C++: they are not meant to be simple; they are meant to be powerful!
In the purest Unix tradition, Make was designed to be tool-agnostic: you can choose which editor to code in, which (if any) preprocessor to use, which compiler and which linker to invoke and with which arguments, and what else to do aside.
And, all of this is controlled by a bunch of text files, which means grep and sed are your friends when you want to change a linker option for several projects.
Make comes from a philosophy which is the opposite of the IDE's ground. Not that the IDE concept is wrong per se, but if you are only used to have the same monolithic behemoth from code typing to binary output, your critics of make sound the same as an industrial fast food cook complaining that artisan patisserie is too complex.
- yet it has excellent defaults for most situations
- it is full blown programming language,
- yet it's syntax is extremely specialized for the purpose and familiar at the same time (it's bash)
- it's basic assumptions/structure are extremely simple (timestamps, dependencies)
- yet it's extremely powerful and can take into account most situations.
It's be extremely Unix-style tool with very simple building blocks that combine together in extremely powerful way. Its fast to learn and easy to master and as such, the best kind of design.
Sometimes making a build with it is a small programming project, yet after using all kinds of built tools, I end up just wishing that I could use make instead.
Would you build a C project with make? One might argue that C could do with a better build system like other languages have. I don't use C much, but I hear that these exist.
As someone who has used make a lot, screw writing makefiles. It's too low-level and I want to be able to build my stuff without lots of headache on multiple platforms (which includes Windows). I hate CMake's weird language, but even that beats makefiles.
Make is easy to learn.
It simplifies a slightly complex task.
Other build tools have a steeper learning curve. If they're more complex than the problem being solved, people won't want to adopt them.
When things get complex, there's the GNU make manual and libraries.
When you have to target multiple platforms, there's autotools, which is really complex and intimidating, but less complex than targeting multiple platforms.
Alternatives to make seem to fit in between make and autotools.
Make sucks. I've also heard that Unix sucks, and C sucks, too. Despite this alleged suckyness, these things not only persist, but accumulate improvements over the years.
reply