Customer Reviews

Debugging Windows Programs: Strategies, Tools, and Techniques for Visual C++ Programmers

5 star:		(10)
4 star:		(1)
3 star:		(1)
2 star:		(1)
1 star:		(0)

 

 

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.

This book should have been included with the MS Visual C++ documentation. If you can say "My code doesn't have bugs, only features," then you may skip this book. I found this book full of tips and tricks and secrets of visual c++ debugging. Just by having this book on your side, you will save hours and hours of frustration trying to find that one line that's keeping you from going home.
Beginning few chapters are basic debugging knowledge every visual C++ programmers should be aware of. It explains more of 'preventive' programming styles so that you notice your bugs before your customers. Various topics including assert and compiler options are well explained, much better than the ones you would find in the vc++ documentation.
I was happy to finally see some explanation on Dr. Watson messages. In Chapter 6: Debugging with Windows, Woodring and McKay explains all the precious information buried in those memory dumps that we often ignore. After all, all those hexadecimal numbers got to mean something, right?
If you have been always unsure about your multithread knowledge, this book contains a good section on multithread programming issues and how to monitor your threads from the debugger.
And for those who can't sleep at night because of some odd bug buried in thousands of lines of code, I recommend jumping right into Chapter 12: Desperate Measures. You are probably too frustrated to think straight now. Let this book help you calm down and look through your code step by step. This chapter simply provides a code checking checklist that you should probably copy down and tape it to your monitor.
For those of you that are starting a fresh batch of code and thinking about buying this book, my recommendation is to read this book first, then code. You'll be a lot happier later. And for those of you that have already written a few million lines of code and trying to debug, you can apply some of the techniques found in this book to build up confidence in your code. I suppose if you live dangerously ("Just let 'er rip and hope for the best"), then most of the things explained in this book will only seem annoying to you, but I'm sure most of you programmers out there would like to know a few neat debugging tricks to show off in front of your co-workers.

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.

Writing versatile C++ is serious business. Moreover, the added complexity of Win32, MFC and ATL make debugging a challenging task. Simple techniques such as use of TRACE() statements and Watch facilities alleviates minor problems. While there are several authoritative texts on C++ and VC++, the same cannot be said for debugging techniques. This book rounds out the library of serious VC++ developers nicely. It is an absolutely amazing text. It's scholarly yet approachable. Moreover, as someone with an extensive library (including C++ and Win32 etc.), I can attest that there is nonetheless "new" information presented to me that is quite useful. The beginning of the text addresses philosophical issues in helping prevent bugs. The next section gives great guidance in actually using the debug facilities of Visual Studio most thoroughly. The last section covers issues specific to COM and multithreading. This text has a wealth of useful information. There is a good introduction to the Intel instruction set and use of MAP files for postmortem debugging. (I wish there were a text of the same caliber that covers use of and debugging Intel's MMX.) This book will definitely help users (beginner or expert) achieve a higher plane(42).

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.

This is the best book in debugging I have ever seen. What I like most about this book in addition to the technical value it has, is being concise and more to the point. There no much unnecessary detail. For people with little patience on reading like me, this will take you directly to the problem you have.

- The book covers the most common issues a developer needs while debugging his application. I will not go into detail, but things like debugging memory problems or finding where your application crashed (in the source code level) having the crash address, to deadlocks and multithreading.

- The best chapter in the book in my openion is the multithreading and deadlock analysis. The best treatment in a book. Its coverage is even better than John Robin's book.

If you have to buy only one book about debugging, buy this one. Only if you are rich, and willing to buy another one just for the sake of it, buy John Robin's

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.

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.

Lots of useful information, particularly the tips for debugging release executables, but very poorly produced as a book.

The copy I received (and returned) appeared to have been made from a badly cropped set of bound photocopies. This is completely unacceptable at this price.

This is a very good book, although it is now a little dated. The explanations on customizing watch windows, and tuning default step over behavior has already payed for itself in terms of time savings.