Appendix B: Books about Debugging

Ag02 Agans, D. Debugging. Amacom, 2002.

The book contains 175 pages of general techniques for diagnosing prob-lems, which can be applied to both hardware and software problems. The index is seven pages long; the book contains no bibliography, appendices, or collateral software. This book suggests nine general principles for trou-bleshooting and debugging. The author presents 45 personal experience anecdotes to motivate readers and illustrate his principles. Most of these are related to debugging electronic hardware or low-level system software.

The most helpful feature of this book is the chapter that contains four extended personal experience anecdotes and explanations of how the nine principles were applied in these situations. The summaries at the end of the chapters are also helpful.

Al02 Allen, E. Bug Patterns in Java. APress, 2002.

The book contains 7 pages of language- and platform-independent debug-ging information, 141 pages of language-dependent debugging informa-tion, and 52 pages related to other phases of the software-development process. The bibliography contains 35 URLs for Web pages and 16 anno-tated book references. The index is 10 pages long; there are 14 pages of appendices, and there is no collateral software. The core of the book is the presentation of 14 bug patterns, one per chapter. The focus of these chap-ters is to explain the causes and prevention of these bug types, rather than the diagnosis of the bugs.

The most helpful parts of the book are (1) a table of 6 pages that pro-vides an alphabetical list of 120 concepts and the corresponding chapter, and (2) a chapter of 10 pages that provides 121 questions that the book answers, organized by chapter.

FT02 Ford, A. R., and Teorey, T. J. Practical Debugging in C++. Prentice Hall, 2002.

The book contains 20 pages of information on common C++ problems, 41 pages of platform-independent debugging information, and 27 pages of tool-specific debugging information. The index is 2 pages long, the bibliog-raphy contains 12 entries, there are 4 pages of appendices, and there is no collateral software.

This book would be most helpful to college students who are learning to program in C++. The most valuable feature is the list of the 32 most common bugs in first programs.

Br01 Brown, M. Debugging Perl. McGraw-Hill, 2001.

The book contains 114 pages of Perl language information, 4 pages of languageand platform-independent debugging information, 118 pages of language-dependent debugging information, and 71 pages related to other phases of the software-development process. The index is 21 pages long, there is no bibliography, there is one appendix of 48 pages, and there is no collateral software.

The most helpful features of the work are the chapters on the Perl debugging modules and the appendix, which contains a complete list of possible error messages, along with explanations of how each message could be generated.

Mc01 McDowell, S. Windows 2000™ Kernel Debugging. Prentice-Hall PTR, 2001.

The book contains 165 pages of platform-dependent debugging information. The index is 6 pages long, there is no bibliography, there are 128 pages of appendices, and there is no collateral software.

The book is aimed at people who support Windows 2000 systems, and programmers who develop device drivers. It would be highly valuable to that audience.

SW01 Scott, P., and Wright E. Perl Debugged. Addison-Wesley, 2001.

The book contains 106 pages of Perl language information, 96 pages of languagedependent debugging information, and 14 pages related to other phases of the software-development process. The index is 7 pages long, there is no bibliography, there are 14 pages of appendices, and there is no collateral software.

The most helpful features of the work are the “Perls of Wisdom,” collected in a reference card at the back, and the chapters on syntax errors, runtime exceptions, and semantic errors.

TH01 Telles, M., and Hsieh, Y. The Science of Debugging. Coriolis Group, 2001.

The book contains 216 pages of language- and platform-independent debugging information, and 230 pages related to other phases of the software-development process. The index is 15 pages long, the bibliography contains 33 entries, there are 10 pages of appendices, and there is no collateral software.

The most helpful feature of the work is the collection of principles in the chapters titled “The General Process of Debugging” and “Debugging Techniques.”

JK00 Jung, D. G., and Kent, J. Debugging Visual Basic. McGraw-Hill, 2000.

The book contains 35 pages of language- and platform-dependent debugging information, 14 pages of information on the VB language, 247 pages on the Microsoft software environment, and 54 pages related to other phases of the software-development process. The index is 18 pages long, there is no bibliography, there are 9 pages of appendices, and there is no collateral software.

The most helpful feature of the work is the chapter on debugging tools.

Le00 Lencevicius, R. Advanced Debugging Methods. Kluwer Academic Publishers, 2000.

The book contains a 13-page summary of current research projects related to runtime debugging and 123 pages describing a query-based tool for debugging object-oriented software systems. The index is 9 pages long, there are 12 pages of appendices, the bibliography contains 204 entries, and there is no collateral software.

The book is a revision of the author’s Ph.D. thesis. It might be of interest to computer science researchers, but has no material that can be used by practicing programmers.

W00 McKay, E. N., and Woodring, M. Debugging Windows Programs. Addison-Wesley, 2000.

The book contains 38 pages of language- and platform-independent debugging information, 43 pages of C++ language information, and 436 pages of

C++/Microsoft-specific debugging information. The index is 32 pages long, the bibliography contains 49 entries, and there is no collateral software.

The most helpful features of the work are the thorough coverage of Microsoft-specific information and the lists of recommended reading at the end of each chapter.

Unfortunately, the book is marred by numerous incorrect statements and unsubstantiated opinions. For example, the authors assert, “One difficulty with optimizers is that they operate on a small window of code. It’s just not feasible for an optimizer to scan the entire body of code and take everything into account to optimize for a loop” (p. 434). This statement was true in the early 1960s. It hasn’t been true for decades. Highly effective loop optimization was available in commercial compilers in the late 1960s. Whole procedure optimizers were available in commercial products in the early 1980s, and products containing whole program optimizers became available in the early 1990s.

Let the reader beware.

PM00 Pappas, C. H., and Murray, W. H. Debugging C++. Osborne/ McGraw-Hill, 2000.

The book contains 7 pages of language- and platform-independent debugging information, 26 pages of C++ language information, 99 pages of Microsoft platform information, 312 pages of C++/Microsoft-specific debugging information, and 49 pages related to other parts of the software-development process. The index is 12 pages long, there is no bibliography, and there is no collateral software.

The detailed examples of debugging Microsoft-specific features are excellent. The publisher should have given the book the title Debugging C++ on Microsoft Windows since it doesn’t provide any coverage of other platforms, such as UNIX TM or Linux TM .

Mi00 Mitchell, W. D. Debugging Java. Osborne/McGraw-Hill, 2000.

The book contains 13 pages of language- and platform-independent debugging information, 69 pages of Java language information, 87 pages of Java-specific debugging information, and 172 pages related to other phases of the software-development process. The index is 19 pages long, there are 78 pages of appendices, and there is no bibliography or collateral software.

The most helpful features of the work are the good overview of Java debugging tools and the appendix that lists commercial software tools available for the Java programmer. The publisher should have given the book the title Java Software Development since the majority of the book isn’t about debugging.

Ro00 Robbins, J. Debugging Applications. Microsoft Press, 2000.

The book contains 25 pages of language- and platform-independent debugging information and 402 pages of C++/Microsoft-specific debugging information. The index is 14 pages long, there are 13 pages of appendices, the bibliography contains 23 annotated entries, and collateral software is included on a CD-ROM.

The detailed examples of debugging Microsoft-specific features are excellent. The publisher should have given the book the title Debugging GUI Applications on Microsoft Windows since it doesn’t provide any coverage of other platforms, such as UNIX TM or Linux TM .

Ba98 Ball, S. Debugging Embedded Microprocessor Systems. Butterworth-Heineman, 1998.

The book contains 7 pages of language- and platform-independent debugging information and 198 pages of system-dependent debugging information, targeted specifically at embedded microprocessor systems. The index is 9 pages long, there are 25 pages of appendices, and there is no bibliography or collateral software.

The reader should have a working knowledge of microprocessor hardware internals. There aren’t many resources for those who debug embedded systems. If you do this type of work, this book is worth reading.

Bu98 Bugg, K. Debugging Visual C++ Windows. Miller-Freeman, 1998.

The book contains 16 pages of language- and platform-independent debugging information and 156 pages of C++/Microsoft-specific debugging information. The index is 13 pages long, there are 20 pages of appendices, there is no bibliography, and collateral software is included on a CD-ROM.

The most helpful feature of the work is that it collects useful information about defects on Windows™ systems and tools that might help a programmer debug defects on windows. The work would have been more helpful if it included some examples that show how to use the information or tools presented to diagnose a bug.

Ni96 Nicolaisen, N. NuMega’s Practical Guide to Debugging 32-bit Windows Applications. IDG Books, 1996.

The book contains 359 pages of language- and platform-dependent debugging information, focusing on the NuMega toolset for C++ applications running on Windows™. The index is 21 pages long, there is no bibliography, there are no appendices, and a demonstration version of NuMega BoundsChecker is included on a CD-ROM.

The most helpful features of the work are the chapters discussing errors on writing to memory, reading from memory errors, pointer errors, and leak errors. A programmer working on Windows™ with Visual C++, but not with the NuMega products, will still find value in the first twelve chapters.

THYS96 Tsai, J. J. P.; Bi, Y.; Yang, S. J. H.; and Smith, R. A. W. Distributed Real-time Systems. John Wiley, 1996.

The book contains 71 pages (3 chapters) of language- and platform-independent debugging information related specifically to distributed real-time systems. The index is 3 pages long, there are no appendices, the bibliography has 444 entries, and there is no collateral software.

There aren’t many resources for those who debug distributed real-time systems. If you do this type of work, this book is worth reading.

Yo95 Young, D. Motif Debugging and Performance Tuning. Prentice Hall, 1995.

The book contains 25 pages of language- and platform-independent debugging information, 57 pages on avoiding software defects, 174 pages of language-and platform-dependent debugging information, 158 pages related to performance tuning, and 145 pages of application case studies. The index is 6 pages long, the bibliography contains 24 entries, and there are no appendices or collateral software.

The most helpful features of the work are the chapters on characterizing bugs, memory bugs, and layout bugs. This is an excellent resource for developers building Motif applications. Developers using other GUI systems might also find some ideas to transfer.

Ne95 Neumann, P.G. Computer Related Risks. Addison-Wesley, 1995.

Chapter 1 introduces fundamental concepts, including a notation that is used in the following chapters to summarize the causes of the problems described. The remainder of the book describes hundreds of problems occurring in societies around the world through the use of computers. Some were caused deliberately, others accidentally. The author analyzes and categorizes the problems and presents recommendations on how to build and use systems so that they pose fewer risks to their users and society. The index is 16 pages long, there are 7 pages of appendices, the bibliography has 179 entries, and there is no collateral software.

The value of this work lies in its educating programmers about the repercussions that software defects can have. It doesn’t teach debugging techniques per se. Managers of computer programmers should read this book.

Pe95 Peterson, I. Fatal Defect. Random House, 1995.

This book is aimed more at the general reading population than Neumann’s book. It discusses fewer computer-related problems that have occurred in society. The discussion is organized around the work of various computer scientists, who are contributing to the analysis and understanding of defective systems. The index is 6 pages long, there are no appendices, the bibliography has 458 entries, and there is no collateral software.

The value of this work lies in its explanations of some of the reasons that software contains defects and of the potential repercussions of serious defects. It doesn’t teach debugging techniques per se. The book is suitable for the noncomputer literate. Managers of computer programmers should read this book.

Sp94 Spuler, D. A. C++ and C Debugging, Testing, and Reliability. Prentice Hall, 1994.

The book contains 59 pages on generating debugging output and using debugging memory allocators for C and C++, 30 pages on software-development phases other than debugging, 28 pages on exception handling in C++ and C, 32 pages on coding methods that make C++ and C code more robust, 23 pages on debugging and testing tools, and 142 pages on a catalog of 167 errors that C++ and C programmers commonly make. The index is 6 pages long, there are 10 pages of appendices, the bibliography has 61 entries, and a 3.25-inch floppy disk is included as collateral software.

The error catalog would be quite helpful to programmers with limited professional experience in C++ and C. If you program in C or C++, you should read this book. Unfortunately, it’s out of print, but if you can find an inexpensive used copy, buy it.

Th92 Thielen, D. No Bugs! Delivering Error-Free Code in C and C++. AddisonWesley, 1992.

The book contains 119 pages on language- and platform-dependent debugging, 25 pages on other phases of the software-development process, and 16 pages on debugging tools (quite obsolete). The index is 8 pages long, there are 31 pages of appendices, there is no bibliography, and there is no collateral software.

If you’re a programmer with limited professional experience in C++ and C, you could benefit from reading this book. The examples in this book are all focused on the 80X86 hardware and Microsoft Windows™ software that was popular when the book was written in 1992. Nonetheless, if you skim (or skip) the 80X86/MS-DOS particulars, there are still useful suggestions in this book. Unfortunately, it’s out of print, but if you program in C or C++ and you can find an inexpensive used copy, buy it.

St92 Stitt, M. Debugging: Creatives Techniques and Tools for Software Repair. John Wiley, 1992.

The book contains 43 pages of language- and platform-independent advice on the debugging process; 136 pages on tools for isolating platform-dependent bugs, including documentation of the software included with the book; 112 pages on methods for isolating platform-dependent bugs, emphasizing MS-DOS and 80X86 systems; 8 pages in an appendix matching problems and methods; 29 pages on system-level knowledge for debugging MS-DOS 80X86 systems; and 50 pages of assembly source code for specialized tools for debugging MS-DOS 80X86 systems. The index is 12 pages long, there is no bibliography, and there is a 5.25-inch floppy disk included as collateral software.

The examples in this book are all focused on the 80X86 hardware and MS-DOS software that was popular when the book was written in 1992. Nonetheless, if you skim (or skip) the 80X86/MS-DOS particulars, there are still a lot of useful suggestions in this book. The chapters have good summaries that omit much of the platform-dependent detail. Unfortu-nately, the book is out of print, but if you can find an inexpensive used copy, buy it.

Ve91 Vesely, E. G. COBOL Debugging Diagnostic Manual. Prentice Hall, 1991.

The book contains 136 pages of language-dependent advice for debugging COBOL programs, 138 pages of source listing of computer-assisted reengineering programs, 36 pages of glossary from ANSI-1974 and ANSI-1985 COBOL manuals, and 8 pages listing annotated COBOL reserved words. The index is 4 pages long, there is no bibliography, and a 5.25-inch floppy disk is included as collateral software. If you’re supporting old COBOL programs, you’ll find this book helpful.

Ko89 Koenig, A. C Traps and Pitfalls. Addison-Wesley, 1989.

The book contains 63 pages of language-dependent common lexical, syntactic, semantic, and linkage bugs; 31 pages of common problems with library functions, the preprocessor, and portability; 3 pages of language-independent advice on the debugging process; and 19 thought questions, distributed over 7 chapters, with answers at the back. The index is 5 pages long, there are 20 pages of appendices, there is no bibliography, and there is no collateral software.

The book would be quite helpful to programmers with limited professional experience in C.

Mu88 Murray, W. R. Automatic Program Debugging for Intelligent Tutoring Systems. Morgan Kaufmann, 1988.

The index is 9 pages long, there are 45 pages of appendices, the bibliography has 82 entries, and there is no collateral software.

The book is a revision of the author’s Ph.D. thesis. The work is valuable in that it educates programmers about what it would take to automate the debugging process. It makes explicit actions that they do implicitly and, thus, provides ideas about how to think about debugging. It doesn’t teach debugging techniques per se.

Jo86 Johnson, W. L. Intention-Based Diagnosis of Novice Programming Errors. Morgan Kaufmann, 1986.

The index is 5 pages long, there are 40 pages of appendices, the bibliography has 71 entries, and there is no collateral software.

The book is a revision of the author’s Ph.D. thesis. The work is valuable in that it educates programmers about what it would take to automate the debugging process. It makes explicit actions that they do implicitly and, thus, provides ideas about how to think about debugging. It doesn’t teach debugging techniques per se.

Wa86 Ward, R. Debugging C. Que Corporation, 1986.

The book contains 13 pages of language-independent advice on the debugging process; 24 pages on program testing; 155 pages on how to isolate language-dependent bugs, emphasizing MSDOS and CP/M systems running on microcomputers; 70 pages on how to use source-level debuggers, interpreters, and integrated environments; 25 pages of source code for a machine-level debugger for Wintel machines; and 13 pages of source code for a trace package that works with the debugger. The index is 7 pages long, the bibliography has 29 entries, and there is no collateral software.

The most helpful features of the work are the chapters titled “Why Is Debugging C Difficult?” and “Stabilizing Pointer Bugs.” The specifics of dealing with pointer problems differ on modern systems, but the principles are sound. The book is out of print, but if you program in C or C++ and you can find an inexpensive used copy, buy it.

Bi85 Binder, R. Application Debugging. Prentice Hall, 1985.

The book contains 13 pages of language-independent advice on the debugging process and 309 pages of IBM-/MVS-specific debugging information, covering COBOL, Fortran, assembly language, and PL/I.

The index is 20 pages long, there are 15 pages of appendices, the bibliography has 9 annotated entries, and there is no collateral software.

Sm84 Smith, T. Secrets of Software Debugging. Tab Books, 1984.

The book contains 31 pages of language-independent advice on the debugging process and 29 pages of computing fundamentals aimed at programming novices. Three complete programs, implemented in BASIC, Pascal, and Apple II assembly language, comprise the bulk of the book (175 pages). Problems actually encountered during their development are analyzed and corrected. The index is 3 pages long, there are 8 pages of appendices, the bibliography has 10 entries, and there is no collateral software.

The work targets an obsolete language/environment and is of historical interest only.

Ce84 Cecil, D. R. Debugging Basic Programs. Tab Books, 1984.

The book contains 4 pages of language-independent advice on the debugging process. The rest of the book demonstrates errors commonly committed by BASIC programmers. It assumes debugging tools limited to statements available in BASIC language processed by an interpreter. The index is 3 pages long, there are no appendices, and there is no bibliography or collateral software.

The work targets an obsolete language/environment and is of historical interest only.

Ca83 Cassel, D. The Structured Alternative: Program Design, Style, and Debugging. Reston Publishing, 1983

The book contains 10 pages of language-independent debugging information. The remainder of the work is devoted to software-development and testing issues. The index is four pages long, there are no appendices, there are three pages of bibliography, and there is no collateral software.

The work confuses testing and debugging and is of limited value.

Cl81 Clary, W. OS Debugging for the COBOL Programmer. Mike Murach Associates, 1981.

The book contains 390 pages of system-dependent information about debugging on IBM 360/370 in COBOL. The index is 2 pages long, there are 61 pages of appendices, and there is no bibliography or collateral software.

The work targets an obsolete language/environment and is of historical interest only.

Br80 Bruce, R. C. Software Debugging for Microcomputers. Reston Publishing, 1980.

The book contains 339 pages of language-dependent information about debugging in BASIC, intermixed with fundamental software engineering principles.

The index is three pages long, there are eight pages of appendices, and there is no bibliography or collateral software. The work targets an obsolete language/environment and is of historical interest only.

VT78 Van Tassel, D. Program Style, Design, Efficiency, Debugging, and Testing. Prentice Hall, 1978.

The chapter on debugging contains 45 pages of largely language-independent advice on how to diagnose and prevent bugs, as well as 15 pages of questions and problems intended to teach or extend debugging skills. The index is 11 pages long, there are 74 exercises in the appendices, the bibliography has 14 entries, and there is no collateral software.

Despite the age of the work, there is still a lot of good advice in the debugging chapter. The exercises would be useful to students.

Ri76 Rindfleisch, D. H. Debugging System 360/370 Programs Using OS and VS Storage Dumps. Prentice Hall, 1976.

The book contains 259 pages of system-dependent information about debugging on IBM 360/370, including information on Fortran and assem-bly programming. The index is 3 pages long, there are 21 pages of appendices, and there is no bibliography or no collateral software.

The work targets an obsolete language/environment and is of historical interest only.

BS73 Brown, A. R., and Sampson, W. A. Program Debugging: The Prevention and Cure of Program Errors. American Elsevier, 1973.

The book contains 16 pages of a language-independent method for debugging based on the Kepner and Tregoe problem-solving method. The remainder of the work is devoted to software-development and testing issues. There is no index, there are 28 pages of appendices, and there is no bibliography or collateral software.

The work confuses testing and debugging and is of limited value.