Debugging Books

Dreaming in Code: Two Dozen Programmers, Three Years, 4,732 Bugs, and One Quest for Transcendent Software

Scott Rosenberg

Amazon Price: $11.16 List Price: $13.95 Usually ships in 24 hours By: Three Rivers Press Amazon Marketplace: 42 new & used starting at $6.49

Buy at Amazon.com

Browse similar items by category:
Subjects -> Business & Investing -> General
Subjects -> Computers & Internet -> Business & Culture -> Culture
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Debugging

Customer Reviews:
Total reviews: 62 Average rating: 4.0 of 5

Editorial Review:

In the 80s, Tracy Kidder's The Soul of a New Machine attempted to define the story of the development of a minicomputer: from the new science to the business and nascent culture of electronic hardware and software that was characteristic of that time. Scott Rosenberg's Dreaming in Code draws on Kidder's model as it attempts to document the state of software, the Internet, and everything circa 2006 through the lens of Chandler, an as-yet-unfinished software application for the management of personal information.

The Chandler project--driven by Mitch Kapor, the founder of Lotus Development and main author of its 1-2-3 spreadsheet, and later co-founder of the Electronic Frontier Foundation--isn't the primary point of Dreaming in Code, though reading about software people and their social behavior is at least as interesting as reading about that of meerkats or monkeys. Rather, Chandler is a rhetorical device with which Rosenberg takes on the big questions: How do software development teams work (or not)? Why does the reuse of software modules rarely work altogether correctly? Does open-source development by volunteers on the Internet lead to innovation or just insanely bifurcated chaos? Chandler helps his readers think more clearly about all of these issues; however, "answers" to these questions are, of course, not to be had, which is one of his points.

The problem with books about technical subjects that aspire to appeal to a general audience, particularly computers and software, is that such subjects are so far outside the realm of familiarity of most people that the prose bogs down in analogy and metaphor. Rosenberg manages to avoid too much of that and deliver a readable account of software development and culture. --David Wall

Memory Dump Analysis Anthology, Volume 1

Dmitry Vostokov

Amazon Price: $26.40 List Price: $40.00 Usually ships in 24 hours By: Opentask Amazon Marketplace: 13 new & used starting at $26.39

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Assembly Language Programming
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Debugging
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Development

Customer Reviews:
Total reviews: 1 Average rating: 5.0 of 5

An excellent Windows debugging resource for the real world! 5 out of 5 stars.
6 of 6 people found this review helpful.

As an Escalation Engineer for a large software company, live debugging and post-mortem memory dump analysis is a part of my daily routine. I often find myself debugging some strange/unique problems, where I am sometimes stuck staring at stacktraces wondering where do I go next... In these times I would often find myself searching the web, trying to find more information, which would mostly leadme to http://www.dumpanalysis.org... On this site, I usually find that Dmitry not only encountered a similar situation before, but has fully documented and classified in-depth debugging information regarding the issue.

It is no surprise that the contents of his book (Memory Dump Analysis Anthology, Volume 1) contained a vast collection of Windows debugging knowledge, fully illustrated, with great explanations of complex topics broken down nicely so that even a beginner can hit the ground running with Windows debugging. This book is a great resource for both beginners wanting to explore the realm of Windows debugging, as well as for professionals who perform debugging (both live and post-mortem) that need a reference for various memory patterns.

In the past it has always been difficult to find a solid source for Windows debugging information, as bits and pieces of this knowledge has been scattered across various sources. It is nice to be able to pick up one resource such as this book, and follow it through to the end and actually build a strong Windows debugging foundation. Complete with code examples, illustrations and screenshots, this is a must have for anyone who is serious about debugging on Windows.

Cheers!
KappA

Editorial Review:

This is a revised, edited, cross-referenced and thematically organized volume of selected DumpAnalysis.org blog posts about crash dump analysis and debugging written in 2006 - 2007 for software engineers developing and maintaining products on Windows platforms, technical support and escalation engineers dealing with complex software issues and general Windows users.

Hunting Security Bugs

Tom Gallagher, Lawrence Landauer, Bryan Jeffries

Amazon Price: $35.98 List Price: $49.99 Usually ships in 24 hours By: Microsoft Press Amazon Marketplace: 42 new & used starting at $1.14

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Web Development -> Security & Encryption -> Encryption
Subjects -> Computers & Internet -> Business & Culture -> Privacy
Subjects -> Computers & Internet -> Networking -> Network Security

Customer Reviews:
Total reviews: 5 Average rating: 4.5 of 5

Editorial Review:

Finding security flaws is now a fundamental development task, yet there has not been adequate documentation of the process used to find security bugs—until now. Before the Internet, computers were deployed in trusted environments and software development and testing practices emphasized functionality over security. As networking technologies emerged, though, times changed and people began to connect their computers together, instead of deploying in silos. However, development and testing practices did not account for attacks that could be mounted over networks.

The material currently available does not provide much practical guidance and the instructions given often fail to cultivate the right mindset and approach to enable people to successfully identify security issues before the software is published. This in-depth, technical reference highlights up-to-date tools, technologies, and techniques for helping find and eliminate vulnerabilities in software. Written for testers by testers, it delivers practical, hands-on guidance on how to find, classify, and assess bugs. In addition, this book covers the thought process behind security testing, use of source code to help in testing, and ways to spot security design flaws.

Writing Solid Code: Microsoft's Techniques for Developing Bug-Free C Programs (Microsoft Programming Series)

Steve Maguire

List Price: $24.95 By: Microsoft Press Amazon Marketplace: 31 new & used starting at $0.45

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> C -> General
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Debugging
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General

Customer Reviews:
Total reviews: 42 Average rating: 3.5 of 5

One of the books to read -- though not the only one 3 out of 5 stars.
0 of 0 people found this review helpful.

You may not be impressed when you see that this is a Microsoft book. You may get bored at the beginning when all the examples are C and most about memory management. But it's worth persisting and reading onward, because sooner or later, some of the examples will look familiar. Simple concepts about what kind of coding leads to more defects, and what kinds are "solid" or robust.

Too old to read, too good to forget 5 out of 5 stars.
0 of 0 people found this review helpful.

I would not read this book now but I'm so sorry the author does not write an updated one! This book really changed the way I wrote code.

Old but still relevant today 4 out of 5 stars.
0 of 0 people found this review helpful.

This book has been recently recommended to me by Amazon based on my previous purchase habits and I decided to go take a look at its description. At first, I was little bit skeptic about the value of a book published in 1993 and prepared with Word for Windows 2.0 because software programming has changed a lot since then! However, it was a very low risk purchase because of its very low price tag so I decided to give it a try and I have been pleasantly surprised!

This book is the proof that that there are few things in programming that are timeless. Errors of the past still occur today. The programming language used for the examples is C but what is taught is also applicable to C++ programming as well. Topics discussed in the book are: assertions, integrity checks, stepping through code with a debugger, how to not design interfaces that are error prone, avoid language features that are error prone and finally the author conclude his book by describing the attitude that a programmer should have. Among other things, a programmer should prioritize safe code before micro-optimizations. All these concepts are written in a style easy to understand filled with anecdotes that make this book a pleasant read.

To conclude, I have not been blown away by the content of this book but I have learn one thing or two and I am glad that I have read it especially with its very low price tag.

Editorial Review:

Any programmer worth their silicon knows that it is wiser to invest time preventing bugs from hatching than to try to exterminate them afterwards. And this is one of the best books for developing a proactive attitude towards electronic entomology. Follow Maguire's advice, and your testers, supervisors and customers will love you. Recommended.

BUGS in Writing, Revised Edition: A Guide to Debugging Your Prose (2nd Edition)

Lyn Dupre

Amazon Price: $26.99 List Price: $29.99 Usually ships in 24 hours By: Addison-Wesley Professional Amazon Marketplace: 39 new & used starting at $10.38

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Debugging
Subjects -> Computers & Internet -> General
Subjects -> Literature & Fiction -> General

Customer Reviews:
Total reviews: 17 Average rating: 4.0 of 5

I don't know if it's art, but I liked it! 5 out of 5 stars.
4 of 5 people found this review helpful.

I just recently finished a technical book and the book and Lyn's advice to be spot on. She flags the problems that I had with my writing style (or lack thereof).

Her style of writing is quirky, but entertaining. I enjoyed it immensely.

If I had bothered to read the book before I started righting my own book, I would have finished my book in much less time.

A cautionary note: this book is for TECHNICAL WRITERS. A book for the scientist who is writing, or the computer programmer who is writing. This book won't work for your novel about summers in Rome.

A good excercise in grammar 4 out of 5 stars.
3 of 4 people found this review helpful.

I particularly enjoyed the many examples Ms. Dupre provided with her topics. She did a good job making rules of grammar hit home. She also prompted you to actually THINK about the subject matter, rather than read the standard counterexamples found in most other grammar texts. For a student in a computer-related program with minimal english courses, this book does a great job in teaching good grammar with little pain.

However, the way the book is organized does make it hard to quickly find grammar rules. It's better used as a learning tool than a reference.

Editorial Review:

Teaches how to recognize common errors instantly by describing what those errors are, in simple & clear terms & to convey the basic principles of good writing. Paper. DLC; English language Rhetoric.

Bug Patterns In Java

Eric Allen

List Price: $34.95 By: Apress Amazon Marketplace: 16 new & used starting at $1.50

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Java -> General
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Debugging
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General

Customer Reviews:
Total reviews: 5 Average rating: 5.0 of 5

Great Guide to Debugging 5 out of 5 stars.
4 of 4 people found this review helpful.

Bugs. All code has them to one degree or another and they always seem to take twice as long to fix as the original code took to write. This book boils thirteen of the most common bugs down to their root causes and formulates them as 'bug patterns'. Each bug pattern describes how to identify the bug by the symptoms it exhibits, why the bug is occurring, and gives one or more suggestions to fix it and prevent it from occurring again.
If the bug you are searching for isn't among one of the thirteen bug patterns covered, the author also covers a methodical approach to tracking down bugs effieciently and quickly. Suggestions on how to prevent bugs from occurring in various stages of the development cycle are also presented, which are helpful even if you aren't currently searching for a bug in your code. Most of the suggestions are based on the XP development model, but the practices that are important are pointed out so they can be incorporated into any other style of development.
Even though debugging doesn't sound like a fun topic, the author has a very readable style and is able to get you excited about preventing and fixing bugs. The chapters have been very well thought out and the book is broken into topics very well. You can read a chapter in about ten minutes or less and feel like you have a good grasp of the topic covered.
This is a great book to partner with a 'best coding practices' type of book, like 'Practical Java' or 'Effective Java'. Those books are really good at describing how Java should be coded. This book gives examples of why those practices should be followed, and how to quickly get back on track when they aren't and something goes wrong.

Editorial Review:

Bug Patterns in Java presents a methodology for diagnosing and debugging computer programs. The act of debugging will be presented as an ideal application of the scientific method. Skill in this area is entirely independent of other programming skills, such as designing for extensibility and reuse. Nevertheless, it is seldom taught explicitly. Eric Allen lays out a theory of debugging, and how it relates to the rest of the development cycle. In particular, he stresses the critical role of unit testing in effective debugging. At the same time, he argues that testing and debugging, while often conflated, are properly considered to be distinct tasks.

Upon laying this groundwork, Allen then discusses various "bug patterns" (recurring relationships between signaled errors and underlying bugs in a program) that occur frequently in computer programs. For each pattern, the book discusses how to identify them, how to treat them, and how to prevent them.

A Bug's Life: The Art and Making of an Epic of Miniature Proportions

Jeff Kurtti

List Price: $40.00 By: Disney Editions Amazon Marketplace: 12 new & used starting at $10.52

Buy at Amazon.com

Browse similar items by category:
Subjects -> Comics & Graphic Novels -> Cartooning
Subjects -> Children's Books -> Literature -> Popular Culture
Subjects -> Children's Books -> Popular Characters -> Disney -> A Bug's Life

Customer Reviews:
Total reviews: 6 Average rating: 4.5 of 5

great pictures, atrocious writing 3 out of 5 stars.
13 of 17 people found this review helpful.

A very handsome book that doesn't appear to've been copyedited at all. The first five pages have more grammatical errors than any ten randomly selected novels. Plus, author Jeff Kurtti's tortured prose stylings seem better suited to a grade 12 english class than a "quality" mass market publication. Still, excellent pictures, an attractive layout, and some good and interesting quotes from the key creatives, albeit rammed bone-headedly in between all the intermittently coherent Kurtti-text. Buy it to look at, not to read.

Wow!!!!!!!!!!!!! 5 out of 5 stars.
4 of 5 people found this review helpful.

A hardcover and full color book on the making of a bugs life.Absolutely wonderful!!Interviews with the directer and clips from the movie.Also encludes many of the story-boards they used.I loved it !!!!!!!

The book for every animators. 5 out of 5 stars.
4 of 5 people found this review helpful.

This book is very much to own for animators and who that love this movie

Editorial Review:

This lavish celebration of "A Bug's Life", the new computer-animated film, profiles the innovative minds behind the movie, its cutting-edge animation techniques, and the movie's unforgettable, lovable characters. Full color.

Find the Bug: A Book of Incorrect Programs

Adam Barr

Amazon Price: $28.62 List Price: $34.99 Usually ships in 24 hours By: Addison-Wesley Professional Amazon Marketplace: 27 new & used starting at $8.62

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Debugging
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Development

Customer Reviews:
Total reviews: 5 Average rating: 4.5 of 5

Going from language to language is of dubious benefit 3 out of 5 stars.
15 of 16 people found this review helpful.

While this book does something that I am in strongly in favor of, I don't agree with the approach. Barr presents a series of code segments that contain bugs and the reader is challenged to find the error(s). The bugs introduced into the code are fairly common, so finding them will be excellent practice for coders at all levels of experience. The segments of code are short, generally less than two pages, so finding the bugs does not require a great deal of searching.
The problem is that the programs are written in C, Python, Java, Perl and x86 assembly. If you are experienced in a particular language, then the bugs will probably not challenge you. However, if you are a novice in a language, the ten pages devoted to introducing the language will not be enough to get you up to speed. I have taught all of these languages and I found it difficult to shift from one language to another. The syntax differences between the languages are enough to confuse even people experienced in all of them. I am also unconvinced that finding bugs in a language you are not using and are unfamiliar with will make you a better programmer.
The general sequence of the bug presentations is:

*) A textual explanation of the problem.
*) The source code.
*) Suggestions of questions to consider.
*) Hints of operations to perform when stepping through the code.
*) Explanation of the bug(s).

Which is certainly a sound approach.
I dithered a bit when trying to settle on a ranking for this book, largely due to the multiple languages. In the end, I settled on three stars because I believe that if you go through this book, it is more likely that instead of doing a few things well, you will do many things poorly.

Mind Bugs: The Origins of Procedural Misconceptions (Learning, Development, and Conceptual Change)

Kurt VanLehn

Amazon Price: $48.00 List Price: $48.00 Usually ships in 2 to 5 weeks By: The MIT Press Amazon Marketplace: 10 new & used starting at $18.00

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Debugging
Subjects -> Computers & Internet -> Computer Science -> Artificial Intelligence -> Cognitive Simulation
Subjects -> Health, Mind & Body -> Psychology & Counseling -> General

Editorial Review:

As children acquire arithmetic skills, they often develop "bugs" - small, local misconceptions that cause systematic errors. Mind Bugs combines a novel cognitive simulation process with careful hypothesis testing to explore how mathematics students acquire procedural skills in instructional settings, focusing in particular on these procedural misconceptions and what they reveal about the learning process.

VanLehn develops a theory of learning that explains how students develop procedural misconceptions that cause systematic errors. He describes a computer program, "Sierra," that simulates learning processes and predicts exactly what types of procedural errors should occur. These predictions are tested with error data from several thousand subjects from schools all over the world. Moreover, each hypothesis of the theory is tested individually by determining how the predictions would change if it were removed from the theory.

Integrating ideas from research in machine learning, artificial intelligence, cognitive psychology, and linguistics, Mind Bugs specifically addresses error patterns on subtraction tests, showing, for example, why some students have an imperfect understanding of the rules for borrowing. Alternative explanatory hypotheses are explored by incorporating them in Sierra in place of the primary hypotheses, and seeing if the program still explains all the subtraction bugs that it explained before.

Kurt VanLehn is Assistant Professor in the Department of Psychology at Carnegie Mellon University. Mind Bugs is included in the series Learning, Development, and Conceptual Change, edited by Lila Gleitman, Susan Carey, Elissa Newport, and Elizabeth Spelke. A Bradford Book

Debug It!: Find, Repair, and Prevent Bugs in Your Code

Paul Butcher

Amazon Price: $23.07 List Price: $34.95 Not yet published By: Pragmatic Bookshelf

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Debugging
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Development

Editorial Review:

If you develop software, sooner or later you're going to discover that it doesn't always behave as you intended. Working out why it's misbehaving can be hard. Sometimes very hard. Debug It! is here to help!

All bugs are different: there is no silver bullet. You've got to rely upon your intellect, intuition, detective skills and yes, even a little luck. But that doesn't mean that you're completely on your own-there is much you can learn from those who have gone before. This book distills decades of hard-won experience gained in the trenches of professional software development, giving you a head-start and arming you with the tools you need to get to the bottom of the problem, whatever you're faced with.

Whether you're writing Java or assembly language, targeting servers or embedded micro-controllers, using agile or traditional approaches, the same basic bug-fixing principles apply. From constructing software that is easy to debug (and incidentally less likely to contain bugs in the first place), through handling bug reports to rolling out your ultimate fix, we'll cover the entire life-cycle of a bug.

You'll learn about the empirical approach, which leverages your software's unique ability to show you what's really happening, the importance of finding a reliable and convenient means of reproducing a bug, and common pitfalls so you can avoid them. You'll see how to use commonly available tools to automatically detect problems before they're reported by customers and how to construct "transparent software" that provides access to critical information and internal state.