Customer Reviews

Debugging Applications for Microsoft® .NET and Microsoft Windows® (Pro-Developer)

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

 

 

Being John Robbin's greatest fan, I have been monitoring the release of this book right after it appeared on amazon. Once It hit the market for real, I got a copy via express delivery and I have to say it's worth the wait. I haven't actually read the whole think yet but its very impressive so far.

John walks the reader through debugging without tears. This edition of the book does contain a lot more information and is very current (a little too current cos all the binaries were built with VS .NET 2003 which is not in the market at this time.
However, this didn't hinder me since I have a copy of the RC. The first part of the book covers coding practices that will reduce the need to debug in the first place. The other parts of the book go into the dirty details of going after bugs with full confidence. From native win32 to managed code to multithreading; its all here.

If you're tired of scratching your head even when you have a debugger in front of you, stop reading my review and get yourself a copy of this book right away.

I bought this book to get a complete knowledge of the .NET framework debugging and got nothing. May be the .NET in the title applies to the fact that the author is using the VS.NET. If you have got the author's previous book on debugging then there is no need to waste money on this one.

It discusses mainly C/C++ debugging in a typical MFC style (ASSERT/VERIFY etc).

Here is the content at a glance:

1. Bugs: Where they come From and How you Solve Them
2. Getting Started Debugging
3. Debugging During Coding

4. Operating System Debugging Support and How Win32 Debuggers Work
5. Advanced Debugger Usage with Visual Studio .NET
6. Advanced .NET Debugging with Visual Studio .NET
7. Advanced Native Code Techniques with Visual Studio .NET
8. Advanced Native Code Techniques with WinDGB

9. Extending the Visual Studio .NET IDE
10. Managed Exception Monitoring
11. Flow Tracing

12. Finding Source and Line Information with Just a Crash Address
13. Crash Handlers
14. Debugging Windows Services and DLLs That Load into Services
15. Multithreaded Deadlocks
16. Automated Testing
17. The Debug C Run-Time Library and Memory Management
18. FastTrace: A High-Performance Tracing Tool for Server Applications
19. Smoothing the Working Set

Appendixes.

As you can tell, there is hardly a .NET stuff to pay for, so for those of us owing the author's previous debugging book, this is just a second edition with .NET appended to confuse buyers!

This book brings a vast amount of Windows-specific debugging information together in one place and has been very helpful to me. Some of this info could be found elsewhere, but only by sorting through dozens of documentation pages and magazine articles, some many years old, and additionally the author adds value by giving very explicit instructions (even providing source code) on how to do things that are often only hinted at in the Microsoft documentation.

Most useful to me were the symbol-server tips, the SuperAssert macro and seeing how it does it what it does, crash handling in general, and the author's insight into why certain things are so slow (like OutputDebugString).

This book does have a not-so-subtle anti-C++ bias, there are little digs at C++ coding techniques throughout the book, which seem a little antiquated and inappropriate in 2005.

In the chapter on the debug C-runtime, I'm really surprised the author does not suggest writing a leak-detection system that captures the callstack at the time of allocation, I've found the C-runtime's file-and-line-oriented leak report fairly useless since the allocation is often deep inside some container class, you really need to know what code caused the allocation, not what code actually did the allocation. And the recommended feature that walks the entire heap every N allocations is unusable (it's too slow) in a large C++ program which might have many thousands of allocations. Also, redefining C++ keywords as suggested seems so evil, there are better ways of doing this.

I believe Windows XP Service Pack 2 changed some Windows internals that affect crash handling/debugging/stack walking, I wouldn't mind seeing an updated volume that covers these changes in detail.

Overall though, an excellent book, the most useful debugging book I've found so far.

Well, that guy that wrote the review before me says he's Robbins's greatest fan. Well, after reading this book, I'd like to claim that distinction for myself.

This was an eye opener from start to finish and a MUST HAVE for any professional developer, even if you aren't using .NET.

Like everything else from Wintellect, this book is superb.

This book is a book for the advanced programmer who says "I already know how to build a halfway decent windows app, how do I take my debugging to the next level and deliver truly good apps?"

This book covers real-world debugging issues that plague programmers and are difficult to solve, such as multi-threading and memory issues amongst others. Also this book has several entertaining real-world scenarios that can help give you perspective on debugging.

However this book is not for the beginner, a solid grasp of programming is essential for this book. However those with a good grasp of what programming is about with at least a basic knowledge of .NET will be right at home with this book.

The original was a gem, and I used it extensively, but the code and tools that came with that version are now out of date. The .NET version adds tremendous value with a whole new suite of power debugging tools that just weren't there before. Although a few of the introductory chapters are similar, it's a huge overhaul of the original once you get into the heart of the book.

I've been using the native code sections of this book, rather than the .NET sections. Most of the book, expecially the power debugging stuff, is still focused on native code. However, I don't think the "Below the belt..." review did this book justice. If you are at all serious about debugging on Windows platforms, read and use this book.

I'm writing this to thank that guy who posted the table of contents in an effort to show how this book is the same as John Robbins' prior - since that is what convinced me to buy it :-)

Not just that it costs a lot less then what people ask for a copy of out of print "first edition", but also seeing the TOC told me that this book made not a small step forward - in particular by ditching that VB thing and opening the doors to windbg -- THE TOOL, if you don't have the money or reason for SoftICE.

Books covering hi-tech need rejuvenation every once in a while and the way John Robbins did it could actually serve as an example on how to do it right.

So, if I see the 3rd sequel this or next year I'm probably going to buy it too - if it gives windbg a 50-50 split with Visual Studio, and a chapter on kd maybe? :-)

As for a "a complete knowledge of the .NET framework debugging" - if you know how to anything under Visual Studio debugger you already know it - say you forget half of what this book is trying to teach you and you are still fine :-). Managed code is so shielded that there's nothing on earth new for debugging - unless you want to dig two levels bellow and go into JIT or PInvoke - in which case you are going to need this book.

I was impressed with the price of this book (used) and the condition of it as I received it. I am thinking of never buying a new book again. The book itself has been a great help in my job of porting about 100,00 lines of code from Visual Studio 6.0 to VS 2008.

As the title says, it covers both debugging applications for Windows and .NET. That is alot of ground to cover and the book still manages to get it all in and keep it interesting for what could be a very dry read.

There are some topics missed. For example: not covered are debugging for CE or Windows Mobile, debugging using virtual machines (VMWare extensions for Visual Studio, etc.) or the shared sources available for ASP.NET or Windows CE. These are minor issues in an outstanding book on the subject.

A must have for every professional Windows developer.

One of the best technical books I ever read.
This book is very enjoyable, well seasoned with humor, and definitely teaching a lot about debugging applications in windows.
I highly recommend this book for anyone who writes C++ code and, like all of us, one day can face an angry customer, after some unexpected crash scenario.