Rating: 
Summary: No Mercy Debugging
Review: C++ bugs can be very difficult to find and can bring tears to the eyes of a programmer easily.(You know the bug is there but you just cant find it to save your life!)After reading the first few chapters of this book, I knew it was a winner.This book shows ways to find bugs in different kinds of C++ programs MFC,COM etc. The most important however is the chapter on memory bugs(a real pain) If you need to hunt down bugs, get this book and your monitor is less likely to end up smashed from your frustrations. This book also points the reader to a lot of other books which should make a better programmer of anyone who bothers to buy them.
Rating: 
Summary: Bad Print
Review: I bought this book and was so shocked to see the print quality of the book. All the left inside pages had incomplete sentences due to print. Not only this the words break into next sentences. I have never seen such a bad quality of print in my life. The font is pathetic. I have to say this but I can guarantee the technical writers/review did not review this book after the print because its impossible to read the pages beacuse the sentences are incomplete and words left out b'cos of mis print.
Is this only my copy or every copy has this problem. Can somebody confirm this? I am surprised how anybody has not noticed this?
Rating:
Summary: Pays for itself within your first project
Review: I wish I had this book before - only discovered it recently. This book pays for itself within your first project. Surgical precision-like debugging. Wealth of information. I hope they are working on a sequel to this book for .Net development.
Rating:
Summary: The Memory Chapter Alone Was Worth the Price
Review: I've been programming for 20+ years with the last five using mostly Visual C++, but I learned some invaluable techniques for debugging memory leaks the first time I cracked it open. I'm looking forward to reading the chapter on postmortem debugging (when all you get is a stack dump).
Rating:
Summary: Stop Reading These and Buy This Book
Review: If you are a Windows programmer, then chances are you use MSVC. If that is the case, then you owe it to yourself to buy this book. I've been using MSVC for five years now, and I thought I new a lot of the tips and tricks, but Mr. McKay is like a god... In addition there is a lot of useful hints and tips on debugging any type of program (not even necessarily Windows programs.) A good book with good ideas for lots of people. My only regrets are: A) This book did not come out last year. B) A large portion of this stands to be out of date with the coming of Visual Studio.NET (this is just a fear I have, I haven't taken a look at the Beta yet, so I don't know.) This is one nerd book I am happy to have purchased and read (other books I'm happy to have stumbled upon and read are "Effective C++" and "Essential COM", if that gives you a feeling for other books of a similar quality in my mind.)
Rating:
Summary: Hands down best book on Windows/VC++ debugging
Review: If you write sofware for Windows using VC++, you cannot afford to not have this book. End of story. Everything that I'd scoured MSDN, MSJ, and news groups for the last 5 years to figure out about how Windows works from a user mode program mechanics point of view (PE format, DLL rebasing, symbols, etc) and debugging techniques is in this book (plus more stuff that I'd not yet found out about). It is well written and understandable. It works as a good overview of the topics and as a reference for dealing with a partiular problem, like post-mortem debugging, debugging memory or multi-threading problems, etc. Pick one up, you won't regret it.
Rating:
Summary: Hands down best book on Windows/VC++ debugging
Review: If you write sofware for Windows using VC++, you cannot afford to not have this book. End of story. Everything that I'd scoured MSDN, MSJ, and news groups for the last 5 years to figure out about how Windows works from a user mode program mechanics point of view (PE format, DLL rebasing, symbols, etc) and debugging techniques is in this book (plus more stuff that I'd not yet found out about). It is well written and understandable. It works as a good overview of the topics and as a reference for dealing with a partiular problem, like post-mortem debugging, debugging memory or multi-threading problems, etc. Pick one up, you won't regret it.
Rating:
Summary: "must have" for general debugging
Review: In my experience, programmers fall into two categories: general (majority) and advanced (few); advanced ones understanding register and stack dumps etc, general ones being lost. This book covers the more general programmer, Robbins book the advanced. Comparing the two, you could write your own debugger and your own "core" dumps (which you can then examine) from Robbins book; with this one you can't, but it covers useful stuff missing from Robbins book (eg. PE format, address space partitioning). As such they have some overlap but supplement each other. Both books are essential to serious developers. I have one gripe with this and Robbins book: neither suggests outputting the mixed source/assembly/machine_code (.COD files); these are essential (without a .PDB) if a crash occurs so that the offending instruction etc. can be found, as many instructions usually follow a line of source; secondly, function locals only show in .CODs (as offsets from EBP) so making them easy to locate on a stack trace.
Rating: 
Summary: In one word: it's very MSPress-like. Half and half.
Review: The book contains a fair amount of useful debugging information, and in that respect it's probably the best there is at the moment. It probably beats "Debugging Applications" by Robbins (though if it does, it's not by much.) On the downside, as every single MS-influenced book it's pretty full of obnoxious baby-talk, spin, outright nonsense, and MS glorification. Here you have two more authors of an expensive book thinking it crucial to waste space pontificating on Hungarian notation (and even that is done in a silly way.) So, while it's got some interesting stuff in it, this book also irritated the [heck] out of me a few times too many.
Rating:
Summary: An invaluable book ¿ packed with immediately useful macros
Review: The vast majority of recommendations are so simple, yet so effective. Even if you only read random sections of this book, it will be of immediate benefit. This book in conjunction with John Robbin's book (Debugging Applications) are invaluable in not just giving you tips on how to find bugs but much more importantly how to code defensively to reduce the chances of bugs occurring in the first place. As the authors mention in the preface, they are not many original ideas in the book - but it is a good consolation of publicly available information. The book adds value by explaining when to use certain techniques and when to use others e.g. Chapter 5 -Using exceptions vs. return values. Because the book is specifically geared to C++ programmers there are some fantastic macros. For instance _CoCreateServer which wraps CoCreateInstance but gives detailed error information if anything goes wrong. Chapter 9 - Debugging Memory was particularly useful. Being able to detect leaking memory in ATL components (just like MFC does) was worth the price of the book alone. My only criticism is the use of the Arial font which makes the book a little getting used to seeing on the printed page.
| 
