To build GNU packages from source the dance is:
./configure --prefix=/usr/local # Or your preferred place
make
make install
The configure script queries your environment for all sorts of relevant details (compiler version, usability of various language characteristics, various libraries, functions that might carry different names, ...) and creates some header files from the result reflecting the required configuration. It also builds the Makefile. Running make by itself will fail, until you run configure there is no Makefile, and so no install target.
Why do you want that specific version of make? That one is a quite stable package, the announcement doesn't show any revolutionary changes.
linux - What are makefiles, 'make install', etc.? - Stack Overflow
makefile - How to install "make" in ubuntu? - Stack Overflow
How do you install .make files? (linux mint) - Software & Applications - Spiceworks Community
How to build from Makefile?
Videos
Run the command:
sudo apt-get install build-essential
Chances are you will need things like gcc to actually do the building so you might as well install those as well. The build-essential package will install other tools used along with make.
sudo apt-get update
sudo apt-get -y install make
(-y = answer 'yes' to any prompts)
Check the installed version:
make -v
./configure is a program that looks at your system configuration and builds some of the system dependencies for your program.
make is a program that looks at your Makefile (which was probably built by configure) and uses the rules in there to build your program. The Makefile can have multiple "targets" which are rule sets to do different things - the default is usually just to compile and link your program. When you say make with no arguments, it runs the default target. When you say make install you're running the install target, which usually installs the binaries or libraries built by the default target in their final locations. clean is another common Makefile target that deletes all the generated files like intermediate object files.
make is part of the build system commonly used in Unix-type systems - binutils.
It looks at make files which hold configuration information and build targets.
Specifically -
- ./configure - this is a script that sets up the environment for the build
- make - calls
makewith the default build target. Normally builds the application. - make install - calls
makewith theinstallbuild target. Normally installs the application.
Make is a general purpose workflow program, usually used for compilation. But it can be used for anything.
When you do something like "make all", the make program executes a rule named "all" from a file in current directory named "Makefile". This rule usually calls the compiler to compile some source code into binaries.
When you do "make install", the make program takes the binaries from the previous step and copies them into some appropriate locations so that they can be accessed. Unlike on Windows, installation just requires copying some libraries and executables and there is no registry requirement as such. In short, "make install" just copies compiled files into appropriate locations.
make install does whatever the Makefile author wants it to do. Typically, by this point, it is too late to change the install directory, as it is often known earlier, during the build, so help files and configuration files can be referenced with the correct pathnames.
Many projects use the GNU Autotools to try to improve their portability among hardware and operating system differences. (Different Unix variants use slightly different headers for declarations of functions that are slightly off the usual path -- except most programs need one or another of the ones declared in different locations.)
When a project does use the Autotools, the normal mantra to install it is:
./configure
make
make install
The ./configure typically allows you to use a command line option like --prefix /opt/apache or something similar to specify a different pathname. /usr/local/ is a common default prefix. It is far easier for locally built software to live in one place and distribution-provided software to live in the "main directories": /usr/ /bin/, and so on. (Packagers are very careful to never touch files in /usr/local/ -- they know it is exclusively for system administrators.)
Anyway, the ./configure --prefix /path/to/new/prefix will set a variable in the Makefile that is available when compiling the program, modifying the manual pages so they point to the correct locations for files, modifying configuration files, etc. So make will build the software specifically for the install location you want and make install will install it into that location.
Most programs can run even without the final make install step -- just ./program_name will often start them up. This is definitely a per-project thing -- some, like postfix, qmail, etc., are made up of many different moving pieces and rely on them all working together. Others, like ls or su might be self-contained enough to execute fine from the directory they were built in. (This is not often useful -- but sometimes very useful.)
However, not all projects use the Autotools -- they are huge, complicated, and miserable to maintain. Hand-written Makefiles are much simpler to write, and I personally think just distributing a simple Makefile with configuration variables available is a lot easier on developers and users both. (Though the ./configure ; make ; make install mantra is really easy on users when it works.)