Make

make is a computer program that automates the compile of Computer programs whose Computer files are Dependency (computer science) on each other. A program typically consists of several files, and a programmer usually only works on a few of them at a time. Make will only recompile the files that need to be updated (files that have been modified since the last compile, or that depend on modified files), which is much faster than simply recompiling the whole program each time. Make was originally created by Stuart Feldman in 1977. Dr. Feldman was working at Bell Labs at the time. Since it is old, many derived tools have appeared that work better. Among these are Berkeley Software Distribution make, GNU make and A-A-P. In 2003 Dr. Feldman [http://campus.acm.org/public/membernet/storypage.May.2004.cfm?story=4&CFID=23207696&CFTOKEN=28895744 received] the ACM [http://www.acm.org/awards/ssaward.html Software System Award] for the invention of this important tool. Other Installation (computer programs) and configuration methods are used for Computer programs without dependencies. Although this is its most typical use, make is also used in other programs as a way of defining what to do when something has changed, and thus triggering appropriate responses within the program. Makefile utilities are frequently used to handle the compilation and/or installation of large pieces of software. Make reads the makefile at current working directory by default, which is a common practice among computer programmers. If no makefile is explicitly named in the make command, make will first look for the default file named "makefile" and then "makefile" in the current directory. These can be hidden files. It can be used to compile only certain subsets of an item or suite of software, and can account for dependencies between various parts of the software. Its input is a list of specifications (usually known as a makefile) describing dependency relationships between the generation of files and programs. The file commonly is maintained in the base directory of a project during the development process. This file lists all of the files in the project and describes the action that needed to be taken on that file to create it or bring it up to calendar date. The makefile is used by the command 'make'. The 'make' program has some intelligence (trait) built in and will not attempt to re-make files that are not out of date. For example it will typically not recompile Source_code that has not changed since its last compile (determined by comparison of dates of files). A makefile consists of commands like this:

 foo.o: foo.c foo.h bar.h
        gcc -o foo.o foo.c

 logobig.ppm: logo.pov
       $(POVRAY) logo.pov -k0 -o logobig.ppm

The first command means that if foo.c, foo.h, or bar.h is newer than foo.o, then foo.o should be remade by running gcc. foo.o is said to ''depend'' on foo.c, foo.h, and bar.h. The second says that logobig.ppm depends on logo.pov and can be made by running POV-Ray. Most makefiles are used to compile Computer programs, but they can be used in any situation where files are made from one another by programs that can be called from the command line. ==A sample makefile==

 # Specify compiler
 CC      ?= gcc

 # Specify compiler options
 CFLAGS  ?= -g 
 LDFLAGS ?= -L/usr/openwin/lib
 LDLIBS  ?= -lX11 -lXext

 # Needed to recognize .c as a file suffix
 .SUFFIXES: $(SUFFIXES) .

 # Executable name
 PROG  = life 

 # List of object file needed for the final program
 OBJS  = main.o window.o Board.o Life.o BoundedBoard.o
 
 all: $(PROG)

 # Program compilation and linking steps
 $(PROG): $(OBJS)
      $(CC) $(CFLAGS) $(LDFLAGS) $(LDLIBS) -o $(PROG) $(OBJS)

 .c.o:
      $(CC) $(CFLAGS) -c $*.c

==Obtaining make== FSF GNU/Linux: [http://www.gnu.org/software/make/ GNU make] + [http://www.gnu.org/software/make/manual/html_chapter/make_toc.html manual]. Cygwin users should consult their administrator for more information. Individual users without an administrator should consult the Cygwin package search on the cygwin website at www.cygwin.com. ==Limitations== make has limitations that may make it unsuitable for some projects. Reasons include: * make doesn't scale up to projects well, often encouraging use of recursive makefiles: [http://www.pcug.org.au/~millerp/rmch/recu-make-cons-harm.html Recursive make considered harmful]. * make's support for target configuration is extremely poor and implemented via global variables. This means that only one configuration exists and there can be no per-target configuration. It also means that targets cannot configure their subtargets, requiring a "fork" of an entire target tree whenever a target at the bottom of the tree needs to be configured in a different way. * make's lack of support for configuration-dependency management. When configuration changes, make does not know it needs to rebuild things. * make's lack of cache for builds: When changing configurations back and forth, make will rebuild again and again. This can be addressed by installing [http://ccache.samba.org CCache] but that only addresses very specific target-assembly types and is slower. * make's lack of command-line abstraction: Configuration is given as specific command line options. Rules are written as specific-tool invocations. This makes makefiles platform-dependent and even specific-tool dependent. * When using program generators, one has problems to include the dynamically generated files in make's runtime knowledgebase and bring them in releation to previously existing files. * Debugging large makefiles is softly speaking not very efficient. Nevertheless, despite these limitations and all the alternatives that have been developed, make remains the de facto standard build tool. It is used in the vast majority of free software projects, large and small alike. Make's long-lasting survival can in part be attributed to its extreme portability, that it is one format that can be used for very different types of software projects and the GNU Build Tools which allievates the pain sometimes felt by using make. ==Other make-like tools== One can find [http://www.a-a-p.org/tools_build.html a very comprehensive list of make replacements] on the [http://www.a-a-p.org/ A-A-P Site]. *cmake is a portable makefile utility. It requires the Cmake lists file to be present and does not seem at present to support the diving makefile concept. *makepp is compatible to (GNU) make, but additionally has an integrated command- and include-parser for determining implicit dependencies automatically. Changed command options and similar influences are recognized. The big make problem of recursion can be elegantly bypassed, so as to guarantee correct builds. Moreover Perl is available at all levels. http://makepp.sf.net *SCons: Improved, cross-platform build system which is implemented using Python programming language, which integrates some features of Automake/Autoconf. Its strength is that the 'makefiles' (which are generically called "SConscript" files; the top-level one is named "SConstruct") can use all the features of the Python programming language programming language. Based on Cons. See http://www.scons.org/. *Cons - http://www.dsmit.com/cons/ *[http://www.canb.auug.org.au/~millerp/cook/cook.html Cook] is a make replacement by [http://www.canb.auug.org.au/~millerp/README.html Peter Miller], with many improvements, including support for variables, user-defined functions, and parallellization and distributions of task building. *Apache Ant *CruiseControl *PyBuild - The Pythonic build system *Perforce Jam - An enhancement of make, using Jamfiles instead of makefiles. *iCompile *Rant: A flexible build tool implemented in Ruby_programming_language. See http://make.ruby-co.de/. *[http://search.cpan.org/dist/Module-Build/ Module::Build] and [http://search.cpan.org/dist/ExtUtils-MakeMaker/ ExtUtils::MakeMaker]. Build and install Perl modules. Module::Build is a replacement for ExtUtils::MakeMaker and does not depend on make. *A-A-P - http://www.a-a-p.org - executes recipies *emake - a commercial GNU Make replacement that automatically breaks makes up for parallel building on a cluster of machines - http://www.electric-cloud.com/ *Mk (Plan 9) - developed originally for Plan 9 (operating system), improved upon make by removing all the vowels from the name, and introducing a completely new syntax that is both easier to read and more powerful. It has been ported to Unix as part of plan9port. [http://plan9.bell-labs.com/sys/doc/mk.html] [http://cm.bell-labs.com/magic/man2html/1/mk] Most Integrated Development Environments also automate the compilation of large software projects. Dependencies are automatically computed from the programs' source code, freeing the user from the task of specifying dependencies. However, these tools are generally specific to a particular programming language. ==References== *Stuart I. Feldman: ''Make-A Program for Maintaining Computer Programs'', Software-Practice and Experience 9(4):255-265 (1979) *Andrew Oram, Steve Talbott: ''Managing Projects with make'', O'Reilly & Associates, ISBN 0-937175-90-0 *Gary V. Vaughan, Ben Elliston, Thomas Tromey: ''Gnu Autoconf, Automake, and Libtool'', Sams, ISBN 1-57870-190-2 *Richard M. Stallman, Roland McGrath: ''Gnu Make: A Program for Directing Recompilation'', Free Software Foundation, ISBN 1882114825 *Clovis L. Tondo, Andrew Nathanson, Eden Yount: ''Mastering Make: A Guide to Building Programs on Dos, Os/2, and Unix Systems'', Prentice Hall, ISBN 0131219065 Computer programming tools

See other meanings of words starting from letter:

M

MA | MB | MC | MD | ME | MF | MG | MH | MI | MJ | MK | ML | MN | MO | MP | MR | MS | MT | MU | MW | MX | MY | MZ |

Words begining with Make:

Make
Make-A-Wish_Foundation
Make-out_party
Make-out_party
Make-over
Make-up
Makea-Tutara
Makeda
Makeda_Davis
Makedon
Makedon
Makedonia
Makedonia_Airport
Makedonija
Makefile
Makefiles
Makejewishbabies
Makekoshi
Makemake
Makeni
Makenzie_Vega
Makeout_party
Makeover
Makepoly.c
Makepolys.c
Maker
Maker's_Mark
Makerere_University
Makerere_University
Makerere_University/Temp
Makerere_University_College
Makerfield_(UK_Parliament_constituency)
MakeRocketGoNow
MakeRocketGoNow
Makersmark
Makers_Mark
Makers_of_Playing_Cards'_Company
Makesysop
Makesysopfail
Makesysopname
Makesysopok
Makesysopsubmit
Makesysoptext
Makesysoptitle
Makeup
Makeup_Oscar
Makeup_Oscar_Nominee
Makeyev_Rocket_Design_Bureau
Makeyourself
MakeYourself.jpeg
Make_articles_useful_for_readers
Make_articles_useful_for_readers
Make_a_Jazz_Noise_here
Make_a_personal_copy
Make_a_personal_copy
Make_A_Webpage
Make_A_Webpage
Make_a_Wish_Foundation
Make_Believe
Make_Believe
Make_Believe_Productions
Make_It_Big
Make_It_Happen
Make_It_Last
Make_it_real
Make_links_only_where_relevant
Make_links_relevant
Make_links_relevant
Make_Links_Relevant_debate
Make_Links_Relevant_debate
Make_links_relevant_talk
Make_Love_To_Me
Make_Love_to_Me
Make_Mine_Music
Make_money_fast
Make_money_fast
Make_Music
Make_omissions_explicit
Make_omissions_explicit
Make_only_links_relavent_to_the_context
Make_only_links_relevant_to_the_context
Make_only_links_relevant_to_the_context
Make_only_links_relevant_to_the_context/Archive_1
Make_only_links_relevant_to_the_context_debate
Make_only_links_where_relevant
Make_out
Make_over
Make_Poverty_History
Make_Poverty_History
Make_Poverty_History_campaign
Make_Poverty_History_campaign
Make_Room!_Make_Room!
Make_Room!_Make_Room!
Make_Room_For_Daddy
Make_Room_for_Daddy
Make_room_for_daddy
Make_Room_for_Lisa
Make_smart_use_of_soft_line_breaks
Make_smart_use_of_soft_line_breaks
Make_technical_articles_accessible
Make_the_Grade
Make_Trax
Make_up
Make_Up_The_Breakdown
Make_Up_the_Breakdown
Make_Up_the_Breakdown
Make_Way_for_Ducklings
Make_Yourself
Make_Yourself
Make_Yourself_At_Home
Make_Yourself_Comfortable