# make

> standard UNIX utility and programming language for build automation

**Wikidata**: [Q300867](https://www.wikidata.org/wiki/Q300867)  
**Wikipedia**: [English](https://en.wikipedia.org/wiki/Make_(software))  
**Source**: https://4ort.xyz/entity/make

## Summary
Make is a standard UNIX utility and programming language designed for build automation, created by Stuart Feldman in 1976. It reads files called Makefiles to determine how to compile and link programs, automating the build process in software development.

## Key Facts
- Created by Stuart Feldman, an American computer scientist, in April 1976
- First published in 1977 as a standard UNIX utility
- Uses Makefiles as its readable file format for build instructions
- Classified as a programming language, scripting language, and build system
- Follows the off-side rule language paradigm and uses macro programming
- Has 34 Wikipedia sitelinks across multiple languages including English, German, French, Japanese, and Russian
- Listed in the Library of Congress authority file with ID n92090404
- Has a Dewey Decimal Classification of 005.13
- Available as free software with an entry in the Free Software Directory
- Supports command line options including -e, -f, -i, -n, -p, -t, -k, -q, -r, -S, and -s

## FAQs
**What is Make used for?**
Make is used for build automation in software development, reading Makefiles to determine how to compile and link programs automatically. It automates the process of turning source code into executable programs by tracking dependencies and only rebuilding what's necessary.

**Who created Make and when?**
Stuart Feldman, an American computer scientist, created Make in April 1976 while working at Bell Labs. The utility was first published in 1977 and became a standard part of UNIX systems.

**What file format does Make use?**
Make uses Makefiles as its primary file format, which are human-readable text files containing build instructions, dependencies, and rules. These files define how to build targets from source files and specify the relationships between different components.

**What programming paradigm does Make follow?**
Make follows the macro programming paradigm and is classified as an off-side rule language. This means it uses indentation to define code blocks and relies heavily on text substitution and pattern matching for its operations.

**What are some related build automation tools?**
Related build automation tools include CMake (a cross-platform build system generator created in 2000), Buildroot (free software), and Windows Package Manager (a FOSS package manager for Windows 10 created in July 2019). These tools serve similar purposes in different environments or with different approaches.

## Why It Matters
Make revolutionized software development by introducing automated build processes, eliminating the need for developers to manually compile and link programs. Before Make, developers had to remember complex compilation commands and manually track dependencies between source files. Make automated this entire process by reading dependency information from Makefiles and only rebuilding components that had changed, dramatically improving development efficiency. Its influence extends beyond just compilation - Make established patterns for dependency tracking, rule-based processing, and automated workflows that influenced countless build tools that followed. The concept of Makefiles became a standard way to describe build processes across different platforms and languages, making it a foundational tool in software engineering that enabled the development of larger, more complex software systems.

## Notable For
- Being one of the earliest and most influential build automation tools, establishing patterns still used today
- Creating the Makefile format, which became a standard way to describe build processes across platforms
- Introducing dependency tracking and incremental builds, concepts that remain central to modern build systems
- Being designed by Stuart Feldman, who later became known for his contributions to computer science and engineering
- Becoming a standard UNIX utility, ensuring widespread adoption across different systems and platforms
- Supporting internationalization through environment variables like LANG, LC_ALL, LC_CTYPE, and LC_MESSAGES
- Providing extensive command line options for controlling build behavior and debugging

## Body
### History and Development
Make was created by Stuart Feldman, an American computer scientist working at Bell Labs, in April 1976. Feldman designed Make to solve the problem of manually tracking dependencies between source files during the compilation process. The utility was first published in 1977 and quickly became a standard part of UNIX systems. Feldman's design philosophy emphasized simplicity and automation, allowing developers to focus on writing code rather than managing build processes.

### Technical Architecture
Make operates by reading Makefiles, which contain rules specifying how to build targets from source files. Each rule consists of a target, prerequisites, and a recipe. Make analyzes these dependencies and determines the minimal set of commands needed to bring targets up to date. The system uses pattern matching and text substitution extensively, following the macro programming paradigm. Make's off-side rule language structure uses indentation to define code blocks, making Makefiles readable while maintaining precise control over build processes.

### Command Line Interface and Options
Make provides extensive command line options for controlling build behavior. The -f option specifies an alternative Makefile, while -n performs a dry run showing what commands would be executed without actually running them. The -k option continues building other targets even if some fail, and -q checks whether targets are up to date without building them. Other options like -i ignore errors, -p print database information, and -t touch files to mark them as up to date. These options give developers fine-grained control over the build process.

### Environment and Configuration
Make reads several environment variables that affect its behavior. The MAKEFLAGS variable passes options to sub-makes, while LANG, LC_ALL, LC_CTYPE, and LC_MESSAGES control internationalization and localization. The PROJECTDIR variable can specify a default project directory, and NLSPATH controls message catalog locations. This environment integration allows Make to adapt to different system configurations and user preferences.

### File Formats and Standards
Make uses Makefiles as its primary file format, which are plain text files containing build instructions. The utility also supports reading from standard input when no file is specified. Make's design follows the Single UNIX Specification, ensuring compatibility across different UNIX-like systems. The tool's file format has influenced countless other build systems, establishing conventions for describing dependencies and build rules that persist in modern tools.

### Ecosystem and Related Tools
Make exists within a broader ecosystem of build automation tools. CMake, created in 2000, provides a cross-platform alternative that generates native build files. Buildroot offers build automation for embedded Linux systems, while Windows Package Manager serves the Windows platform. These tools often complement or replace Make in specific contexts, but Make's influence is evident in their design and functionality.

### Standards and Specifications
Make is specified in The Open Group Base Specifications, Issue 7, ensuring consistent behavior across compliant systems. The utility's command line options, environment variables, and behavior are formally defined in these specifications. Make also has entries in various authority databases, including the Library of Congress (n92090404) and the German National Library (GND ID 4334388-0), reflecting its importance in computing history.

### Programming Paradigm and Language Features
As a macro programming language, Make relies heavily on text substitution and pattern matching. Its off-side rule structure uses indentation to define scope, similar to languages like Python. Make's programming model is declarative rather than imperative - developers specify what needs to be built and how components relate, rather than writing step-by-step instructions. This approach enables Make to optimize builds by only processing what's necessary based on file modification times and dependency relationships.

### Internationalization and Localization
Make supports multiple languages through its integration with system internationalization facilities. The utility reads environment variables like LANG and LC_MESSAGES to determine the appropriate language for output messages. This internationalization support, combined with Make's presence in 34 different language Wikipedias, demonstrates its global adoption and importance in software development communities worldwide.

### Classification and Cataloging
Make is classified under Dewey Decimal Classification 005.13, placing it in the category of computer programming and software development tools. The utility has a Freebase ID (/m/017ws5) and is cataloged in various authority files and directories. Its VIAF ID (176684165) and multiple aliases (including Make-файл, Make.exe, and ملفات البناء) reflect its international recognition and usage across different computing cultures.

## References

1. Freebase Data Dumps. 2013
2. Integrated Authority File
3. [The Open Group](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/make.html)