The Art of Debugging with GDB, DDD, and Eclipse (Paperback)

by Norman Matloff (Author), Peter Jay Salzman (Author)
Key Phrases: program crashes, seg fault, void printtree, New Thread, Multiple Activities Context, Other Tools (more...)

Editorial Reviews

Product Description

Debugging is crucial to successful software development, but even many experienced programmers find it challenging. Sophisticated debugging tools are available, yet it may be difficult to determine which features are useful in which situations. The Art of Debugging is your guide to making the debugging process more efficient and effective.

The Art of Debugging illustrates the use three of the most popular debugging tools on Linux/Unix platforms: GDB, DDD, and Eclipse. The text-command based GDB (the GNU Project Debugger) is included with most distributions. DDD is a popular GUI front end for GDB, while Eclipse provides a complete integrated development environment.

In addition to offering specific advice for debugging with each tool, authors Norm Matloff and Pete Salzman cover general strategies for improving the process of finding and fixing coding errors, including how to:

• Inspect variables and data structures
• Understand segmentation faults and core dumps
• Know why your program crashes or throws exceptions
• Use features like catchpoints, convenience variables, and artificial arrays
• Avoid common debugging pitfalls

Real world examples of coding errors help to clarify the authors' guiding principles, and coverage of complex topics like thread, client-server, GUI, and parallel programming debugging will make you even more proficient. You'll also learn how to prevent errors in the first place with text editors, compilers, error reporting, and static code checkers.

Whether you dread the thought of debugging your programs or simply want to improve your current debugging efforts, you'll find a valuable ally in The Art of Debugging.

About the Author
Norman Matloff, a computer science professor at UC Davis, is the author of several popular public-domain software packages and online tutorials.

Peter Jay Salzman earned his PhD in physics from UC Davis and founded the Linux Users Group of Davis. He is currently a programmer with a Wall Street financial firm.

Product Details

• Paperback: 280 pages
• Publisher: No Starch Press; illustrated edition edition (September 29, 2008)
• Language: English
• ISBN-10: 1593271743
• ISBN-13: 978-1593271749
• Product Dimensions: 9.2 x 6.9 x 0.9 inches
• Shipping Weight: 1.2 pounds (View shipping rates and policies)
• Average Customer Review: 5.0 out of 5 stars See all reviews (3 customer reviews)
• Amazon.com Sales Rank: #286,759 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #16 in	Books > Computers & Internet > Programming > Languages & Tools > Debugging
  #86 in	Books > Computers & Internet > Programming > Software Design, Testing & Engineering > Testing

Customer Reviews

Most Helpful Customer Reviews

10 of 11 people found the following review helpful:

5.0 out of 5 stars Quite a gem!, February 2, 2009

By	Mark K. (California, USA) - See all my reviews

I must come clean first - I know the authors. Peter asked me to review one of the sections in the book many ages ago when the book was in its infancy. The book has progressed much since then, and I must admit this is much more than I was expecting from a book about debugging!

Chapters 1 through 3 are the starter chapters that discuss the core debugging paradigms such as breakpoints and variable analysis. Chapter 1 goes through some of the basic concepts of debugging for those new to the idea (e.g., hobbyists and just-out-of-college programmers) but it's probably less useful for those already familiar with the concept. Chapter 2 goes through the basic debugging operations, such as setting breakpoints and analyzing variables, with an emphasis on how breakpoints can be set, cleared, and triggered using various methods. Chapter 3 goes through more on how variables of different storages can be viewed and displayed.

Chapters 4 and 5 are where things start to get interesting. Chapter 4 discusses how the debugger can be used to analyze core dumps, and touches on operating system concepts just enough to be productive in debugging for those not familiar with OS architectures. Chapter 5 discusses debugging threaded applications. As examples, applications written using popular multi-threaded and multi-process libraries such as pthread, MPI, and OpenMP are discussed, which makes the chapter more practical.

Chapter 6 is an interesting chapter. Section 6.1 goes through some common compiler error messages and how one should interpret them. They're concepts all first semester programming course students should read. It should be read either before chapter 1 or immediately after for beginning programmers, but it's also an entertaining section to read for the experienced programmers who goes through what the section discusses on a daily basis without ever giving it a second thought anymore. Section 6.2 should be a great read for anyone whose hair turned gray trying to debug Curses or NCurses applications under UNIX.

Chapter 7 discusses various tricks programmers use to write less buggy programs. Most of these are widely known concepts that are rarely taught in class - Vim tricks for matching parentheses, syntax highlighting, using errno and perror, libraries for catching buffer overflows, etc. Mentioning of the __LINENO__ directive is strangely lacking in this chapter, and I'm not sure how useful lint is these days but the chapter looks as complete as one would expect. The chapter also delightfully introduces strace and ltrace, though more examples would be helpful for those not familiar with OS concepts.

The final chapter is for those that want to use GDB/DDD/Eclipse in other languages. I have never felt the need to use debuggers with scripts but I probably would sing a different tune once I start using it.

The book admittedly has a Linux slant to it, but practical examples need a practical platform under which to give the examples and Linux is as accessible as it gets for most people. Most of the discussions are applicable in any platform, but they are especially applicable in Linux and UNIX variants. Chapters 1 and 6 should be a part of all introductory programming courses and should provide a good starting point to which a seasoned programmer can point a new programmer. The remaining chapters are relatively easy read yet packed with useful information to which programmers will refer back asking themselves, "what was that command that does ...?"

3 of 7 people found the following review helpful:

5.0 out of 5 stars Worth the price (many times over!), January 30, 2009

By	Alexander Reyngold (New York, NY) - See all my reviews (REAL NAME)

I found this book to be an excellent introduction to debugging with GDB. However, this book takes you beyond merely an introduction but also to a fairly advanced level. I highly recommend this book.

2 of 6 people found the following review helpful:

5.0 out of 5 stars Great Resource For Linux/Unix Developers, December 5, 2008

By	Daniel McKinnon (Tewksbury, MA USA) - See all my reviews (TOP 500 REVIEWER)

'The Art of Debugging with GDB, DDD, and Eclipse' is a great book for developers who work primarily on the Linux/Unix side of things and want to improve their debugging skillset. Packed with 250+ pages of material spread over 8 chapters, you will learn the basics of how to debug, what to look for, how to deal with major issues and all the goodies! If you are primarily a developer outside the .NET world, this is a good resource to read and learn from.

***** RECOMMENDED