|
The Developer's Guide to Debugging | 
 enlarge | Authors: Thorsten Grötker, Ulrich Holtmann, Holger Keding, Markus Wloka
Publisher: Springer
Category: Book
List Price: $99.00
Buy Used: $67.00
You Save: $32.00 (32%)
New (23) Used (8) from $67.00
Avg. Customer Rating:  8 reviews
Sales Rank: 346453
Media: Hardcover
Edition: 1
Number Of Items: 1
Pages: 224
Shipping Weight (lbs): 1.1
Dimensions (in): 9.3 x 6.3 x 0.7
ISBN: 1402055390
Dewey Decimal Number: 005
EAN: 9781402055393
ASIN: 1402055390
Publication Date: September 11, 2008
Availability: Usually ships in 1-2 business days
|
| Similar Items:
|
| Editorial Reviews:
Product Description
Software has bugs. Period. That's true, unfortunately. Even the good old "hello, world" program, known to virtually every C and C++ programmer in the world, can be considered to be buggy. Developing software means having to deal with defects; old ones, new ones, ones you created yourself, and those that others brought to life. Software developers debug programs for a living. Hence, good debugging skills are a must-have. That said, it is regrettable that debugging is hardly taught in engineering schools. That's how the idea for this book was born. The Developer's Guide to Debugging is a book for both professional software developers seeking to broaden their skills and students that want to learn the tricks of the trade from the ground up. With small examples and exercises it is well suited to accompany a CS course or lecture. At the same time it can be used as a reference guide to address problems as the need arises. This book goes beyond the level of simple source code debugging scenarios. In addition, it covers the most frequent real-world problems from the areas of program linking, memory access, parallel processing and performance analysis. The picture is completed by chapters covering static checkers and techniques to write code that leans well towards debugging. While the focus lies on C and C++, the workhorses of the software industry, one can apply many techniques described in The Developer's Guide to Debugging to programs written in other languages.
|
| Customer Reviews: Read 3 more reviews...
The Art of Debugging! November 10, 2008
2 out of 2 found this review helpful
This book is unique in many respects. First, there is no other book I know of that covers the topic of program debugging even though I found myself educating countless engineers on how to properly and methodically debug programs. Up to now, this knowledge is passed down "in the field" from experienced software writers to their younger colleagues. Second, it is quite comprehensive and covers a pleasantly broad set of topics ranging from the type of bugs and their origin to memory debugging, parallel program debugging, runtime monitoring, link-time related bugs or even profiling. Third, the book can be enjoyed cover to cover with gems (astute way to use debugging tools) that will surprise every software programmers save, perhaps, the most seasoned veteran. Students will find the book equally pleasant as it remains truly accessible and should be read by every person who intends to major in software engineering. Debuggers are wonderful tools, yet extremely rich. It can take years to discover/develop debugging methods. The book will help all newcomers to zero in on the critical tools and methods. The material is made extremely relevant with a substantial amount of efforts devoted to the discussion of specific concrete tools (e.g., gdb, valgrind, gprof, quantify, dmalloc, etc..). The focus is unmistakably on UNIX related tools (albeit with a clear effort to show the equivalent tools in a Microsoft setting).
As a brief summary, the book start in chapters 1 through 3 by discussing the nature and source of bugs, which classes of bugs exist (from benign to mid and severe) and finally how to get started with the simplest form of debugging: tracing and inspecting. Chapters 4 through 6 focus on memory related issues, i.e., they focus on memory leaks, memory corruption, memory protocol violations (e.g., double delete) as well as memory performance profiling and improvements. Chapter 7 briefly touches on debugging parallel code (a truly difficult task). Chapter 8 and 9 focus on problem related to the build/link/run process and environment. The last three chapters cover more advanced topics for sophisticated instrumentation/observation techniques (e.g., conditional breakpoints, watch points, signaling, dealing with statics, dump analysis and runtime changes to the state).
Naturally, it is quite difficult to cover every single aspects and tools related to the debugging process so some tools are not covered in the book. The sole omission that is noteworthy is the DTrace tools (created at SUN and available on both Solaris and Apple Mac OS X) which offers an amazing array of instrumentation tools. This does not however diminish the value of the text that I will highly recommend to my own students. A second edition will surely address this omission.
All in all, this is an excellent text that will please many developers who will most certainly find themselves referring back to it again and again. Highly recommended.
The Developer's Guide to Debugging November 10, 2008
2 out of 2 found this review helpful
A solid text on debugging and profiling for C/C++ programming. It identifies the available tools, both open source and proprietary, explains good debugging methodologies, and provides brief but informative examples. It covers a lot of ground so the level of detail is limited, but it is the best overall compendium of this information that I have seen.
A compendium on debugging November 2, 2008
3 out of 3 found this review helpful
This book provides an excellent treatment of debugging techniques in C/C++ and is must-read for all serious software engineers. It contains practical advice and introduces a wide variety of debugging methods, ranging from the simple to the sophisticated. The book will prove valuable to the novice and the expert programmer alike. The illustrations and examples will be particularly useful to the new programmer for whom debugging is often ignored to their detriment later on. The expert will find the many specialized debugging tools and techniques interesting and useful. This is the rare book that will appeal to both audiences.
Helpful for both novice and experienced practitioners (and a good read, too!) October 7, 2008
1 out of 1 found this review helpful
While the focus of this work is somewhat narrower than the title suggests, it does an excellent job of covering the debugging of C/C++ programs with a non-exclusive emphasis of the Linux and Unix environments. It contains a wealth of practical advice, ranging from basic methodology and debug-friendly code style to detailed usage examples of a plethora of dedicated software tools.
The easy-to-read text allows beginners to get started by introducing the use of a classical source-level debugger such as GDB. It then proceeds to cover a wide variety of techniques, some of them often unfamiliar to even experienced developers (e.g., the use of LD_DEBUG). Among the most useful parts of the book is the discussion of a number of open-source and commercial debugging tools based on practical examples, including memory and performance optimization and the debugging of multi-threaded parallel programs. Both the specific use of the tool (such as command line options) as well as the interpretation of its output are well explained. These descriptions considerably lower the barrier-of-entry for using the sometimes very powerful multi-function tools (e.g. valgrind) and give the reader a good base for diving into the tool-specific documentation.
In summary, the book should be quite helpful for most C/C++ developers. I definitely will recommend it to my students who are working on such projects.
Debug behind the scenes.... October 2, 2008
2 out of 3 found this review helpful
Are you a marketing executive in the software tools industry? Then this is the book for you. If you have written your last line of C-code more than a decade ago, such as myself, you will find that the world has evolved quite a lot from "printf" debugging.
If your customer is no longer calling the hotline, but starts to elevate the issue to you, it is time for you to understand, what is going on behind the scenes in your engineering organization. What are the secret ingridients of their debugging soup to cure the problem?
The book offers a very comprehensive review of all relevant techniques. It shows the basics as well as advanced techniques and can serve as a good reference for the challenges and solutions of software tools debugging. The authors do a good job of balancing the book for readability for novices and as well offering practical examples which drill a little deeper.
I highly recommend the book for anybody managing complex software tools. Know what your engineering team is talking about - more power to you!
|
|
|
| | Gourmet Coffee |
|
|
|
| Sponsors |
|
|
|
|
