Now, you have the basics of compiling using GCC.
Of course, you want to give it some flags so that it will
work hard to identify potential problems in your code.
But what if you have a really large program like one with
hundreds of source files
and many of thousands of lines of code?
You could just tell GCC that you want to compile star.c,
all the C files in the current directory.
But don't mean you recompile every file even
if you just make one small change somewhere.
That would take a lot of time
and really harm your productivity.
Speaking of which, XKCD
which is one of my favorite web comics,
has a great comic about time wasted compiling.
You could instead try to
manually pick out which files to recompile.
This would be tedious and error-prone.
If you miss one,
you'll end up with strange errors in your program.
So, what should you do?
You should use a tool for building large programs such as
Make which is great not only for building large programs,
but for building pretty much anything.
For example, all of programming,
my textbook which this course is based
on was built with Make.
The input to Make is
a Makefile which specifies the targets of your build,
that is, what things should Make build for you?
It also specifies the dependencies
which you can think of as the inputs to build a target.
If one of the dependencies
changes then the target needs to be rebuilt.
One target might be a dependency of another target,
in which case rebuilding the
first means that you have to rebuild the second.
The Makefile also specifies
the recipes to build
a target from the files that it depends on.
These are the commands to run to
make the target from the files that depends on.
To understand dependencies a little better,
let's suppose you want to build myProgram.
To build myProgram, you link
three object files shown here.
This means that myProgram depends on these three files.
If any of them get recompiled,
we need to re-link myProgram.
If abc.o is compiled from
abc.c then there's depends on
a relationship between these two files too.
Likewise, if abc.c includes
abc.h then whenever we change the header file,
we would want to recompile the abc.o object file.
Likewise, xyz.o might depend
on a C file and some header files.
We may end up including one header file and
many C files as we develop a large project.
Finally, main.o depends on
main.c and one of our header files.
Now, if we change xyz.c,
we need to recompile xyz.o since xyz.o depends on xyz.c.
We don't need to recompile any of our other object files.
We do however need to re-link our program since,
myProgram depends on xyz.o.
If we change the xyz.h header file,
we would need to recompile
two object files and then re-link the program.
Fortunately, once we tell Make about
these dependencies and what
commands are needed to build a target,
it will figure out which targets need to be
rebuilt and run the corresponding commands for us.
