Internals of GCC.

It’s funny, I’ve been using gcc for like two years and there’s still hundreds of things I completely ignore about it. I wasn’t fully aware of what it did let alone how. That’s why I really found interesting this podcast, as we delve into the processes that are being carried out in order to make a set of consecutive cone lines into actual commands that the computer is able to interpret.

There are three different parts that make a compiler which include: a front end, an intermediate and a back end. Each of them is separate from one another and yet the communication among them is vital for the process of compilation. This allows the programs to be portable and not hardware dependent. Also, this gives more freedom to develop different PC architectures without worrying about compatibility.

At the beginning of the podcast, the invited one makes an interesting observation where he states that knowing the inner processes that take place inside a compiler might not be necessary but can be useful. I’ve been thinking about it and realized how knowing these things might help me define a problem or how to optimize performance. The first one means that I can understand why a program isn’t working and maybe can solve it. The second one implies I can write code that has a better performance if I know the target platform of my program.

In the end, knowing about compilers can be both interesting and meaningful for our lives as programmers. First you stop ignoring how a machine that runs on ones and zeroes can read statements written in English and you can develop ways to get the most use out of the compilers. This is also helpful if you want to ensure compatibility and portability among different platforms which many developers are interested into.