3. Build Diversity Management¶
Let’s list some diversities that the Makefiles need to handle.
3.1. Platform / Host¶
Platform/Host used for compilation - Windows - Linux - Mac
e.g. On linux like systems, you will get access to command
rm to remove a file, or
cp to copy a file. On windows, these files are not available by default. So, how do you handle such differences?
If you are little more versed with Makefiles, then you must also know that there is a concept of
shell in Makefiles. Which one would you choose?
Which compiler are you using for this compilation?
Assuming you are compiling on Windows, the build system may have many choices of the compilers.
Visual Studio and it’s various versions
GCC / GCC GNU C / GNUC G++
GCC based cross compilers
If your software product is compiled using different compilers, then you will have to handle such complexities.
You may have to invoke
cl.exe in some case,
gcc in some other. (And the list goes on)
If you are using IDEs, then when ever you add or remove one file from one IDE, you will have to do same thing manually for other IDEs. Sometimes for different versions of the same IDE.
If you are using Makefiles for compilation, the Makefiles have to provide same information to visual studio compiler
CL and GCC Compilers
gcc (e.g. Include paths and defiles) with different syntax. e.g. using
-D for gcc based systems to provide include paths and defines and
/D for Visual Studio based systems. The Makefiles have to handle such complexity.
This is just tip of the iceberg…. There are many compiler and linker flags as well.
3.3. Choice of different libraries.¶
Your product may be dependent on other Vendors.
Assuming you are developing in C++ and you use the standard template library there are many options for the choice of implementation of the standard template library. See https://en.wikipedia.org/wiki/Standard_Template_Library#Implementations
So, how easily do you select swith across these STL Implementations?
3.4. Makefiles just keep getting complex (and slow)¶
There are small decisions that the Makefiles have to take for all above diversities/variants. All such decisions in make files pile up and generally slows down the build. Ir-respective of platform, such decisions have to be evaluated inside Makefiles and it becomes very complex to maintain such decisions as well.
Makefile generators take a pragmatic approach for this problem. The generators first detect what is the scope and parameters of build and then generate an optimized Makefiles. The generated makefiles are many times faster than the Manually written makefiles. We also get one more advantage, the build system generates does not only generate Makefile, but also generates IDE Files.