Advanced C and C++ Compiling

Being a member of my company's engineering team with the longest tenure, I've been recently given a hint by my company's management to get prepared to take on the role of software architect/integrator. Never being comfortable dealing with compiler/linker issues I've started searching for anything that could help me to boost my knowledge. My more experienced friends provided a few good initial tips. First, they mentioned "Linkers and Loaders". The Drepper article was their second suggestion. Finally, they mentioned a fairly recent book written by a guy named after an Italian city ("Milan something"). Despite its obvious greatness, the "Linkers and Loaders" book wasn't tailored for my EE/telecom/software background. I simply lacked the insight into many initial concepts. I've also read the Drepper article and kind of understood fair amount of it. The things that still bothered me were the looming lack of my hands-on experience and the lack of a good starting point. Finally, I've got this book. Bingo! It gave me exactly what I needed - the whole course starting with precise explanation of initial concepts, garnished with simple code examples. The screen printouts helped me get an idea of what to expect as a result. Above all, the exquisite and sometimes funny illustrations were powerful in explaining the concepts. The book has several qualities rarely found elsewhere: First, to the best of my knowledge, it is the only book that provides a 'black box' overview of the C/C++ building process. It does not go too far into the depths of compiling/linking/loading, but all the explanations provide a good overview of the field. Second, it is obviously written by a professional for the professionals.The author obviously knows how the engineering hands-on developers think. He points out the most potent and the most operational details which once absorbed can keep you afloat at all times. Third, it provides a huge amounts of relevant, hard-to-find information. Some of the chapters (e.g. duplicate symbols handling) are not found elsewhere. Finally, if for no other reason, the quick reference information in the last few chapters alone is worth having this book on the shelf. A must have for any serious professional in the field!

A gold mine of technical information on compilers/linkers/loaders and how C/C++ affect them. Easily one of the best technical books in terms of content that I've read in probably 5 years. Despite the great content and walkthroughs, it suffers from two main issues: 1. It's primarily Linux-specific, though a lot of the concepts apply to Windows. 2. There are a plethora of typographical errors. There are lots of missing spaces between words in tables, missing or extra articles (like "the"). Diagrams are readable but are sometimes fuzzy, probably due to being enlarged. However, I've only found one error effecting the technical content (".bas" instead of ".bss"). This book is still incredible and I would make it required reading for teams producing or consuming shared or static libraries. Already gotten my money's worth out of this book multiple times over. A second edition of this book with the above issues addressed would likely become a long-lived classic.

This book was all over the map. It wasn't in depth in ways I wanted it, and provided a lot of information I didn't think belong. For example, it spends a lot of time discussing specific tools for multiple platforms (Unixes and Windows). This made this book feel more like a reference manual thank something you might want to read through. I could see some people benefiting from this approach. But I didn't like it.

Each program is destined to exist as a block of binary sequences. Source code is the blueprint intent but the block of binary is the result. Quality control over the results can only go so far from the point of view of the blueprint. Sometimes you have to take a look at the end result. This book teaches the background, ways, and whys of using various tools to confirm a few aspects of binary files to address version conflicts and loading of the correct Windows DLLs or Linux Shared Objects used by a program. The book is deep and long but it is all relevant and gives you the tools necessary to understand what happened when the compiler and linker took over and created the program. You also learn how to influence that process with greater certainty.

This is not a computer science textbook. The material presented here is something that will be useful to real-life coders: people who build and use libraries with low level programming languages such as C and C++. If you ever got frustrated by the "undefined reference to" linker error on Linux, or its ugly cousin from Microsoft world "unresolved external symbol", this book will help you understand the magic behind construction and loading of binaries on the two popular platforms. Don't be afraid of reading some assembly language - you'll find the snippets all over the book, but they are very well explained and commented. Most of the space in the book is spent on explaining the complex but very practical concepts related to the re-use of binaries. The last few chapters are down-to earth tutorials and tool descriptions that can be used as a reference long after you will have read the book.

This book is concrete and to the point on subject of putting together, understanding and analysing "stuff" that you get after you compile your source code. This is a book which will teach you methods of building building_blocks together. Analysing and understanding things produced after code gets compiled. This is a book that would and will recommend after one learns how to write code.

There isn't many publication of internal build processes. This is one of them. It covers linking internals, shared libraries and some other . This is the only one position I read which explain how symbol version works. It's more Linux than Windows focused but author tries to cover both.

As per its contents It is a very very good book. I totally reccomend it. However, the printing quality is disappointing. It is a shame that such a good book is printed this way. It is not worth spending more than 50 euros on a book printed this way. It is a shame because as I said the book is very good

I've been waiting for the book on this topic for a very long time. The author said it right - you can't be a master of C/C++ programming without handling the compiling and linking issues with ease, and also - there is surprisingly little information on this topic solidified in the form of a single book. The way how it is written is amazing. Don't remember when it was the last time when I went through the technical book with such an ease. The author just knows how to tell the things in the most effective way. The flow of thoughts and pace of exposing the important facts is perfect, written by a technical mind for the technical minds. Plenty of carefully tailored yet perfectly simple examples guide you right through the topics. All you need is working OS with the platform-specific compiler (Ubuntu on VMWare Fusion in my case with gcc/g++ installed) and a little time to go through the examples. Before you know it, you find yourself navigating your way through the stuff of which you previously had very limited or no knowledge whatsoever. The collections of recipes (last 2-3 chapters/HowTo's section) where some of the rarely found tips are exposed is simply brilliant and worth every penny. This book definitely found its place in my collection of books to take to a desert island.