Customer Reviews

Debug It!: Find, Repair, and Prevent Bugs in Your Code (Pragmatic Programmers)

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

 

 

Earlier this year, I had the opportunity to do a technical review of Paul Butcher's new book "Debug It!" and now that it's been published I'm pleased to be able to review the final product. A number of classic programming books, such as Steve Maguire's "Writing Solid Code" or Steve McConnell's "Code Complete", touch on debugging as one aspect of the software development process, but I'm not sure that I've ever seen or read an entire book devoted to the topic of debugging software. In that regard, Paul's new book fills a pretty interesting niche.

Paul breaks the debugging process up into four stages: reproduce, diagnose, fix and reflect. These stages are covered in detail in the first five chapters of the book, and this is the most important section. In the chapter on reproducing bugs, he touches on topics such as how to control the environmental conditions under which bugs manifests themselves, and techniques for reproducing the inputs that trigger the bugs. He also addresses some of the difficulties involved in dealing with especially difficult-to-reproduce nondeterministic bugs. In the chapter on diagnosis, Paul moves on to the process of forming a hypothesis about what's causing the bug and then performing experiments to refine that hypothesis until you settle in on a root cause. There are a lot of useful guidelines here, including my favorite: Only change one thing at a time! The chapter on fixing bugs is relatively short, which reflects the reality that once you understand what's going on it's usually not that difficult to fix the problem. Here the author stresses the importance of adding regression tests, and making sure that you're fixing the root cause and not merely the symptoms. The last step is to reflect on the significance of this bug and what it might be telling you about the overall quality of your code (e.g. are similar bugs lurking elsewhere in the code?)

The second section of the book ("The Bigger Picture") takes a higher-level look at the issues surrounding software bugs, namely, how do you create an environment such that you stay on top of bugs and not fall into an "infinite defects" situation. It addresses topics such as tracking bugs and working with users and the support staff to better understand the bugs they're seeing in production. The third section of the book ("Debug-Fu") is sort of a hodge-podge of more advanced topics, I suppose. Some of the information in these later chapters is arguably out of place in this book. For example, Chapter 9, "The Ideal Debugging Environment," stresses the importance of having automated tests, a continuous build system, and so forth. There's no question that this is good advice; I'm just not sure that it's completely on-topic for this book. Having said that, they are good disciplines for any programmer to have, and if the stuff in the rest of this book is new to you there's a good change that Paul's advice on testing and continuous builds is new to you too.

It is important to note that the focus of this book is the debugging mindset, and strategies and techniques that you'll use when debugging software. It does not teach you how to use any particular debugging tools. If you merely want to learn how to use the GNU debugger (gdb), or the graphical debugger in your IDE of choice, this is not the book for you.

In conclusion, I would highly recommend "Debug It!" to any junior-level programmer who's interested in developing a more disciplined approach to debugging. If you're not a junior-level programmer but still feel like you waste a lot of time debugging, you will probably find this book helpful as well. It's like having a mentor sitting there with you, teaching you how to take your debugging game to the next level.

Debug It! is now on my shelf beside classics like The Pragmatic Programmer and Steve McConnell's Code Complete.

While Debug It! hews to its pragmatic nature, walking the reader through how to approach debugging in a consistent and logical manner, this book also covers how to design for testability (including TDD and code coverage) and how to make a number of tricky debugging scenarios more manageable.

In fact, I recently used a suggestion from the book to flush out a nasty threading bug we were having a hard time reproducing.

Highly recommended!

Too many people think that debugging just means "using the debugger." Like any tool, debuggers can provide valuable information, but the ability to get into the experimental mindset is much more valuable. This book has its priorities in order. It lays down the foundation for the debugging process first, before getting into specific techniques and tools.

Newer developers will get the most out of this book, as it lays the groundwork for solid practices---like finding the minimal reproduction of a bug, or adding logging non-invasively.

Intermediate developers will be able to use the catalogue of techniques like an artist's palette. "Have I tried changing the timing to make this concurrency problem happen sooner? Have I tested this boundary condition?"

Experts will pick up a trick or two as well, such as automatic checking of exception-safety.

The book sprinkles rallying cries throughout: "One Change at a Time," "Suspect Your Own Code First," and so on. These will be useful as reminders even for readers who think they've been there, done that.

If you write code, you need to know how to figure out what to do when it goes wrong. That's what this book is all about. It's an often overlooked art (or science?) and this book brings together a wide range of methodologies, techniques and mind-sets to help you hunt down the cause of, and fix, bugs.

The writing style is informal and extremely easy to read, and the book is broken up in a logical and helpful way. It's full of anecdotal examples as well as code samples, both of which help to bring the text to life and to clarify the finer details of the points being made.

Overall: if your job (or hobby) depends on writing or testing software, then this book is definitely for you.

"Debug It!" covers a topic not many programmers and developers spend time thinking about - fixing problems in their own and others code. Prior to this book, learning to debug, fix, and eventually avoid bugs was a process of experience. With Paul's book, programmers and developers can apply well-defined techniques to debugging and increase their productivity.

The book is well written and easily approachable for just about anyone. Especially valuable are the sections on talking with non-technical staff and writing code that can help debug itself. If I have a complaint about the book, it's certainly not with the content. Even though the paper the book is printed on is heavier stock, it feels cheap.

This book addresses an area of software development that is often
overlooked yet inevitable: dealing with bugs. Paul does an excellent job
of explaining the technical, intellectual, and psychological aspects of
all phases of debugging: preventing bugs in the first place, diagnosing
and fixing bugs, and making sure that the same bugs don't happen
again. Applying any or all of the ideas from this book will improve the
overall quality of your software projects.

I thoroughly enjoyed reading "Debug It!", not only because it is filled
with useful techniques and best practices, but also for the author's
style, wit, and stories to which developers can relate. Sure, the technical
issues are well covered but how Paul also explains the psychological
angles is what makes this book exceptional.

This book is an excellent step by step guide to the entire debugging process. It not only includes all the steps that should be carried out as a part of the debugging process, it also covers them in the book in the exaact same order in which they need to be carried out, it makes suggestions as to various ways to carry out each step, and warnings as to what can happen if you don't work through the steps sufficiently thoroughly. The book also makes it clear how debugging is an integral part of the program development process and the sorts of problems that deferring debugging to the end of the development process can cause.

If there is one area where the book falls short it is that it concentrates more on how debugging fits with program development and doesn;'t go into as much detail as it could on the relationship between debugging and testing (although this was probably more noticable for me as I had just finished reviewing a book on testing before starting on this one on debugging and so had testing fresh in my mind).

This is one book that all development programmers would benefit greatly from but one which many of them will overlook due to their having a mistaken preconception of what debugging is all about.

This, coupled with David Agans' "Debugging", is a must-have on a programmer's bookshelf.

Code goes wrong, systems get tetchy, and you need a logical approach to dealing with problems. Butcher's book lays out lots of great tips and practices for finding, fixing, and preventing bugs in your software. I love his emphasis on empirical, measured approaches to troubleshooting, and I also like that he draws a clear border between finding and fixing bugs. You really do need to step back and take a breath after you've found a pesky bug, because you'll want a different approach for fixing it and preventing other similar bugs.

"Debug It!" puts a great emphasis on controlling the environment and isolating one thing at a time as you work through finding bugs. Butcher's sections making nondeterministic bugs deterministic and his logical steps for approaching bugs are wonderful. I also LOVE that he emphasizes, strongly, that the debugger is a tool of last resort. An important tool, but one to use only after you've exhausted other avenues. (I'm a firm believer the debugger is a time sink. Manually stepping through code is a horrible use of your time.)

Butcher covers a great many topics from the team's culture to methodologies. Along the way he offers insight on tracking your bugs, practical tooling advice around assertions, and finishes up with a great section on Anti-Patterns. Here you'll find some great reading around culture (had to work with a Prima Donna, anyone?), methodologies, and team culture (Code Ownership, FTW!).

This really was a tremendous book, and I highly recommend it!

If you like Pragmatic Programmer, you will like this book as well. It has good tips for debugging s/w. It also gives a lot of interesting "Lessons Learned" experienced by the author.

DEBUG IT! FIND, REPAIR, AND PREVENT BUGS IN YOUR CODE is for professional programmers who want to use new tools and approaches to tackling code bugs. Here secrets of professional debuggers covers all stages of bug life cycles, from making easy debugging software to detection, diagnosis and fix. Approaches show how to use software to hone in on real issues in code, and offer keys to working with support staff and developing more efficient methods. Any library catering to professional programmers must have this.