---
title: Eboard 06  Automating work with Make
number: 06
section: eboards
held: 2017-03-02
---
CSC 282.01, Class 06:  Automating work with Make
================================================

_Overview_

* Preliminaries
    * Notes and news
    * Upcoming work
    * Questions
* Background - Why Make?
* Key Make issues
* Rules
* Variables
* Automatic variables
* Default targets
* Practice

### News / Etc.

* No class next week.  Use the time to work on the homework.
* I will try to mix lecture, discussion, recitation, and work today.
  We'll see how it goes.

### Upcoming work

* Build an arbitrary-precision-integer library and associated files.
  (Details in today's class)

### Good things to do

* CS extras
* CS table
* Rosenfield symposium on techology and stuff
* Q&A on new gender inclusive housing March 13 12-1 or 7-8pm in JRC 101.
* March 9-12 Playboy of the Western World, 7:30 Thu-Sat, 2:00 Sunday.
  Watch ST wish that she could hit lots of people with sticks.

### Questions

Background - Why Make?
----------------------

* We type long and complex incantations to create our programs, particularly
  when we have large projects. 
* We should document those incantations.
* Once you've put incantations in a file, there's no reason for you to
  type them ever again (or even copy and paste them).  (Up arrow or
  bang history may help.)
* When you inherit / download someone else's project, there's an overhead
  in figuring out which incantations are important
* Make was designed to address these and similar issues
* Also helps us avoid rebuilding unnecessary things

Key Make issues
---------------

* Target: Thing you want to build or do.
    * Thing: I want to build my application
    * Action: Get rid of the cruft
* Dependencies: What I need to have built already to build my application.
  To build gimp, I need gimplib.a built already.  
    * Dependencies can be chained.  To build gimplib.a, I need gimp-tools.o
      and gimp-image-format.o and ...
* Actions: The incantations
* We put Targets, Dependencies, and Actions together into Rules
* We benefit from Variables
* We benefit from Generic rules
* Some variables can be provided for us (such as "Upon what do I depend?")
* It's good to have customs, particularly default targets.

Rules
-----

Three parts: Targets, Dependencies, and Actions 

```
target: dependencies
        action1
        action2
        action3
```

```
foo: foo.c
        gcc -o foo -g -Wall foo.c
bar: bar.c
        gcc -o bar -g -Wall bar.c
```

Variables
---------

```
CFLAGS = -g -Wall
foo: foo.c
        gcc -o foo $(CFLAGS) foo.c
bar: bar.c
        gcc -o bar $(CFLAGS) bar.c
```

Automatic variables
-------------------

Let's avoid repetition by referring to things by their role.

* `$@` the target
* `$^` the dependencies
* `$<` the first dependency

```
CFLAGS = -g -Wall
foo: foo.c
        gcc -o $@ $(CFLAGS) $<
bar: bar.c
        gcc -o $@ $(CFLAGS) $<
```

Generic rules
-------------

Use `%` for "Something"

```
CFLAGS = -g -Wall
%: %.c
        gcc -o $@ $(CFLAGS) $<
``` 

Standard targets
----------------

* `all`, appears first, what your goals are.  When you just type `make`,
  make attempts to make the target of the first specific rule.
* `check`, run your test programs
* `install`, installs your program / you may not write
* `clean`, remove cruft
* `distclean`, remove cruft and anything you built
* `dist`, make a Tarball 

Practice
--------