- Series: Developer Reference
- Paperback: 592 pages
- Publisher: Microsoft Press; 1 edition (May 25, 2012)
- Language: English
- ISBN-10: 0735662789
- ISBN-13: 978-0735662780
- Product Dimensions: 7.2 x 1.3 x 8.9 inches
- Shipping Weight: 2 pounds (View shipping rates and policies)
- Average Customer Review: 4.5 out of 5 stars See all reviews (9 customer reviews)
- Amazon Best Sellers Rank: #639,419 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Inside Windows Debugging (Developer Reference) 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
Prepare for your professional certification with study guides and exam prep tools from Wiley. See more
Frequently bought together
Customers who bought this item also bought
About the Author
Tarik Soulami is a principal development lead on the Windows Fundamentals Team at Microsoft.
Browse award-winning titles. See more
If you are a seller for this product, would you like to suggest updates through seller support?
Top Customer Reviews
Overall excellent book, well worth adding to the library.
Chapters include: 1. How to develop software for Windows 2. Getting started (debugging for fun and profit section) 3. How debuggers work (pretty basic but very complete, covers both User and Kernel modes) 4. Postmortem Debugging (JIT vs. dump techniques. Goes much deeper than the day to day systems engineer will usually go) 5. Beyond the Basics (the real meat of the book-- awesome-- data vs. code breakpoints, scripts, etc.) 6. Code analysis tools (fair to C/++ and sharp, with many actual/not just pseudo/ code examples that are well thought out and RUN); 7. Expert Debugging Tricks (we finally get to the fun and profit piece-- many techniques that are effective but unusual, and probably wouldn't be attempted by the usual coder without this book's help on avoiding potholes); 8 and 9 are a whole collection of very cool "scenarios" covering all the NIGHTMARES created by threads and multiprocessors such as race conditions, deadlocks, stack/heap and access problems, etc. These two chapters are worth the price of the whole book; 10 gets into the console subsystem and concludes this section.
Section two (about 120 pages) switches themes with three chapters about Xperf. In short, if you try to run traces as you develop your software using just ETW (event tracing for Windows), you'll soon get overwhelmed and give it up. This means you're losing one of the best "secret sauces" of the Windows 7 SDK (a way to integrate what's already been perfected, instead of reinventing every wheel, with proven code connected with an already debugged ETW web). The way to tap into that secret sauce IS Xperf.
The two excellent appendices give user and kernel debug quick start examples that make this book as much as a reference and tutorial as a step by step learning guide.
Beyond debugging, there is a LOT of information on how to develop superior software USING the debugger, not for debugging, but for software analysis, code vs. operating system, security, and development cycle issues like static vs. runtime analysis. Any good or prospective windows developer will benefit from this wealth of info. This is over 500 pages PACKED with wisdom and experience, well worth the price as a career enhancer or builder.
The obvious things are covered, but I hoped for more detail 'inside' debugging for windows
It could also do with a better explanation for how a process is put together, the information is all there, but scattered around the place.
With all the latest programming languages and integrated development environments aimed at making writing software applications more accessible, creating applications has never been easier than today. Unfortunately, creating an application is only one part of the equation, getting it to work correctly is the other - usually much harder - part. This book focuses on exactly that harder part; identifying, tracing and resolving bugs in your application as well as preventing them in the first place.
Many still think of debugging as an activity after a software application has been finished and users start to experience issues that require investigation. This, however, is far from the truth these days since many development idioms such as test-driven development (TDD) actually promote debugging during development phases.
The book is divided into three parts, the first providing a bit of background about the evolution and architecture of Windows, the Windows Developer Interface as well as the Microsoft Developer Tools. The second part introduces the basics of debugging, how the Windows debuggers actually work and debugging your application after a crash (postmortem) before moving to more advanced techniques such as scripting the debugger, debugging the WOW64 environment, code analysis tools, debugging system internals as well as looking at common debugging scenarios. The third part introduces strategies to trace and analyze application behavior using different mechanism and tools such as the Event Tracing for Windows (ETW) and the accompanying Windows Performance Analysis Tool (Xperf). Finally, two appendices provide a quick start on how to use the WinDbg debugger to accomplish both user-mode and kernel-mode debugging tasks.
This book is not aimed at the novice developer by any means since a general understanding of C++ and/or C# as well as the Win32 platform and/or the .NET framework is required. The author does provide an excellent job by introducing basic concepts prior to moving to more advanced topics so that nobody really should get lost while moving from chapter to chapter. By not just preaching the theories but also presenting real-world debugging scenarios, the author also manages to provide developers with methods and tools they immediately can use in their daily routine.
I have always been a fan of most books coming from Microsoft Press and this one is no exception: a wealth of information using an inside look into the underlying mechanics and paired with an engaging writing style makes for another book every serious developer should have on his/her shelf.