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.
