Remember Make? You know, the program that runs when you type “make” at the command-line?

I use Make all the time at home. I’ve worked at seven software companies, and I’ve only ever dealt with one makefile at work. The makefile in question was only used for the Linux version of the product. At that company, Linux was a low priority and the makefile always felt like an afterthought.

Lately, I’ve been in mobile development and Make is even more scarce. In a room full of Linux nerds at a party, I asked out loud

“who killed Make?”, and somebody said,

“What are you talking about? I wrote a makefile yesterday.”

Apparently Make isn’t dead after all. The Wikipedia article says:

Though integrated development environments and language-specific compiler features can also be used to manage a build process, Make remains widely used, especially in Unix.

That’s great and all, but I think of make as being a multi-purpose program that runs on almost any computer, so it disappoints me to observe it relegated to the Linux universe and used only to compile legacy C code.

I think this happens a lot: a group of brilliant people develop a flexible tool that can handle a variety of use-cases. The tool gets popular for one particular use-case, and then everybody thinks that’s all it can do. Eventually the tool and the use-case become synonymous (What is X? It’s a tool for doing Y.) And all the blood sweat and tears of those brilliant people go down the drain.

Well, sometimes that’s just the way things go. Time marches on. It’s out with the old build system, in with the new. And unless you’re stuck on Linux writing C, you’re better off using the current, fully-featured IDE whatever it is, XCode, Eclipse, Android Studio or Microsoft Visual Studio. This is largely true, and these are all great pieces of software, but they are not replacements for Make, and here’s why:

Make is not a tool for compiling software.

Make is a language for defining a dependence graph.

Any time you use programs that take files as input and generate files as output (which is pretty much always), situations arise where some files need to update whenever certain other files change. Inevitably, the way in which files depend on each other gets complex. Make can help you manage that complexity by automating the update process.

The need to update files based on dependences is not exclusive to C-based development on Linux.

• Maybe you’re writing a document in TeX with diagrams made in Illustrator and the PDF needs to re-render any time one of the diagrams changes.

• Maybe you have a custom script that scrapes comments from the source of the numerical analysis API you’re writing and uses them to build the developer website.

• Perhaps the documentation and library files for your proprietary Matlab module need to be copied into a directory along with sample code and then zipped.

Any development process that involves more than one piece of software is going to have a dependence graph. But in a world where Make is dismissed as the build tool for linux neckbeards, what people tend to do (whether or not they realize it) is memorize the graph and perform updates by hand. This leads to such situations as:

Oh, the client needs a new package, uh... is this one current? Let me check the created date. Wednesday. Was that after the bug fix? I think it was, but hang on, I’m not sure the documentation in this package reflects the API changes that we did last week, because I might have forgotten at the time to do the doc generation step. I guess I’ll just remake the whole thing.

Make exists to liberate you from that nonsense. Why not use it?