Make

Make
Name	Make
Developer	Various (originally Stuart Feldman)
Initial release	1977
Latest release	Varies by implementation
Programming language	C, shell scripts
Operating system	Unix, Linux, BSD, Microsoft Windows
License	Various

Make Make is a build automation tool introduced in 1977 to manage the compilation and linking of source code into executable programs and other targets. It uses dependency graphs and timestamp-based rules to determine which parts of a project require rebuilding, enabling incremental compilation for projects of varying size. Make remains influential across software projects, continuous integration environments like Jenkins (software), and package systems such as Debian and FreeBSD ports.

History

Make originated at Bell Labs and was created by Stuart Feldman for the Unix operating system, emerging alongside utilities such as ed and lex. Early adoption spread through projects hosted at institutions like MIT and Stanford Linear Accelerator Center, influencing build practices used in BSD distributions and the GNU Project. Over time, the original utility inspired alternative implementations and extensions by organizations including Sun Microsystems and Microsoft, as well as adaptations for platforms like VAX/VMS and MS-DOS. Major cultural moments include its integration into toolchains for systems developed at AT&T and its role in shaping the workflows of large-scale projects such as the Linux kernel and X Window System.

Purpose and Features

Make's primary purpose is to automate the transformation of source artifacts into derived artifacts by specifying rules that relate targets to prerequisites and commands. Core features include timestamp-based dependency checking, pattern rules, automatic variables, and conditional execution facilities that interact with tools such as gcc, clang, and ld. Makefiles allow grouping of compilation steps for toolchains like Autoconf, Automake, and CMake-driven projects, and are used in systems managed by RPM and Debian GNU/Linux packaging workflows. Integration points exist with version control systems such as Git and build servers like Travis CI and CircleCI.

Syntax and Usage

Makefiles express build logic via rules of the form "target: prerequisites" followed by command lines executed by a shell like Bourne shell or bash. Special targets and variables (for example, implicit rules and macros) enable reuse across projects including projects at Mozilla and Apache Software Foundation repositories. Users employ pattern rules and suffix rules to generalize actions across file types common in projects from LLVM and NetBSD. Phony targets, include directives, and conditional constructs allow Makefiles to interoperate with configuration systems such as those used by Autotools in projects like GCC and GNU Emacs.

Implementations and Variants

Multiple implementations exist, each providing compatibility and extensions: the original Unix make, GNU Make maintained by the Free Software Foundation, and platform-specific variants such as Microsoft nmake and BSD make. Other notable variants and successors include pmake used in some NetBSD and OpenBSD contexts, as well as build systems that replace or wrap make, such as SCons, Ninja, Bazel (software), and Meson. Commercial and research alternatives have appeared in projects at institutions like Carnegie Mellon University and MIT CSAIL, reflecting differing design goals around parallelism, reproducibility, and declarative specification.

Integration and Tooling

Make integrates with configuration tools such as Autoconf and Automake, and is embedded in IDEs and editors including Emacs, Vim, and Visual Studio Code via extensions. Continuous integration and delivery platforms like Jenkins (software), GitLab CI/CD, and GitHub Actions commonly invoke make targets to run test suites, packaging, and deployment. Packaging ecosystems—examples include FreeBSD Ports Collection, Debian, and Fedora Project—leverage Makefiles for build recipes, while cross-compilation toolchains for embedded systems from vendors such as ARM Holdings use make-driven flows. Profiling and analysis tools like gprof and Valgrind often integrate with make-based build commands.

Criticisms and Limitations

Critics point to limitations in expressiveness and reproducibility, citing ambiguous dependency specification, fragile timestamp semantics, and platform-specific shell behavior across systems like Windows and Unix-like environments. Large projects such as Chromium and Android (operating system) have moved to alternatives addressing parallelism and incremental build correctness due to challenges with make's implicit rule resolution and scalability. Complexity in Makefile maintenance has driven adoption of higher-level meta-build systems at organizations like Google and Facebook that emphasize hermetic builds and deterministic outputs. Despite these critiques, make implementations remain widely used where simplicity, ubiquity, and integration with legacy ecosystems—illustrated by its presence in BSD and GNU software—are priorities.

Category:Build automation tools