The reasons why you will need this book are clear: You write software (for desktop or embedded systems) and you will have to deal with bugs. Not only in your own code but also in the relation to other libraries and frameworks in modern design flows. It's a good idea to have systematic approach to debugging as a personal skill. And even more important'it's good to have such a strategy before you find yourself in a complex project. Debugging takes the major portion of time, it's usually performed in-between or after the implementation phase when deadlines are approaching and time is getting really a problem!
The authors start with comprehensible bug scenarios (C/C++ sample source code is available for download), show usable tool environments based on industrial-strength tool suites, covering open source as well as commercial products for source code debugging, performance and memory analysis. And they give bridges to a useful test and check strategies (learning debugging not only to find bugs but also to prevent them). The authors introduce some of the the state-of-the-art debugging tools very practically with reference to the documentation (appendix A, debugger commands and appendix B, access to the tools). One could say that reading the manuals does the same job. No it doesn't, because the magic happens within the books view of tools, the discussion of mechanisms behind typical bug scenarios ("meet the bug family"), debugging strategies, and bug prevention. And to be honest, often we take the debuggers manuals when we're deeply involved in the debugging process. And that's far too late and lacks any strategy. The book gives a chance to acquire these skills before and in a structured way. The goals of each section in the book are clearly described at the beginning and summarized at the end in "lessons learned" boxes.
But the authors not only discuss the pure question of 'running' or 'not running', i.e. 'bugs' or 'no bugs' on source code or linker level. Furthermore the book also covers memory problems, performance issues and the debugging of parallel programs. Both topics are crucial for modern software running on today's hardware platforms'for desktop and embedded systems. Finally, the book gives valuable hints to write debuggable code and to the usage of checks and tests. If you face the situation of time pressure, complex software structures, and nasty bugs, it is very valuable to have debugging strategies, fluid tool handling, and the infrastructure glue between always at your fingertips. I find that the "Developers Guide to Debugging" is a comprehensive introduction and a very good guide to professional debugging strategies.
I only can emphasize the words above. If you find out that debugging with powerful tools is usefull after the project was started. Bad idea! But how can you get a feeling whats are the necessary skills without a already started project?
Now this book should be taken into account. The authors descibes scenarios directly connected to the daily business with very hands-on and practical relevant suggestions.
This book is definitly no pure theoretically pamphlet which illuminates every last detail. If you need something like that - read the man-page of these tools. But, you get that incredibly important feeling/overview about debugging with this book. Because if you take the wrong way to catch your bugs, you are lost and spend hours and hours senseless using the wrong approach.