Nothing Special   »   [go: up one dir, main page]

skip to main content
Skip header Section
Bug Patterns in JavaSeptember 2002
Publisher:
  • APress L. P.
ISBN:978-1-59059-061-4
Published:01 September 2002
Pages:
450
Skip Bibliometrics Section
Reflects downloads up to 20 Nov 2024Bibliometrics
Skip Abstract Section
Abstract

From the Publisher:

Just as good programming skills involve the knowledge of many design patterns, which developers can combine and apply in various contexts, good debugging skills involve knowledge of bug patterns. Bug patterns are recurring correlations between signaled errors and underlying bugs in a program. This concept is not novel to programming. Medical doctors rely on similar types of correlations when diagnosing disease. They learn to do so by working closely with senior doctors during their internships. Their very education focuses on learning to make such diagnoses. In contrast, software engineers education focuses on design processes and algorithmic analysis. These skills are, of course, important, but little attention is paid to teaching the process of debugging.

"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.

Once laying this groundwork, he 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.

Cited By

  1. ACM
    Sudakrishnan S, Madhavan J, Whitehead E and Renau J Understanding bug fix patterns in verilog Proceedings of the 2008 international working conference on Mining software repositories, (39-42)
  2. ACM
    Shen H, Zhang S, Zhao J, Fang J and Yao S XFindBugs Proceedings of the 8th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering, (70-76)
  3. ACM
    Coelho R, Rashid A, von Staa A, Noble J, Kulesza U and Lucena C A catalogue of bug patterns for exception handling in aspect-oriented programs Proceedings of the 15th Conference on Pattern Languages of Programs, (1-13)
  4. ACM
    Boroday S, Petrenko A, Singh J and Hallal H Dynamic analysis of java applications for multithreaded antipatterns Proceedings of the third international workshop on Dynamic analysis, (1-7)
  5. ACM
    Girgis H, Jayaraman B and Gestwicki P Visualizing errors in object oriented programs Companion to the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications, (156-157)
  6. ACM
    Murphy-Hill E, Quitslund P and Black A Removing duplication from java.io Companion to the 20th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications, (282-291)
  7. Farchi E and Harrington B Assisting the code review process using simple pattern recognition Proceedings of the First Haifa international conference on Hardware and Software Verification and Testing, (103-115)
  8. ACM
    Boroday S, Petrenko A, Singh J and Hallal H (2005). Dynamic analysis of java applications for multithreaded antipatterns, ACM SIGSOFT Software Engineering Notes, 30:4, (1-7), Online publication date: 1-Jul-2005.
  9. ACM
    Murphy-Hill E and Black A Traits Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications, (275-282)
  10. ACM
    Hovemeyer D and Pugh W (2004). Finding bugs is easy, ACM SIGPLAN Notices, 39:12, (92-106), Online publication date: 1-Dec-2004.
Contributors

Reviews

Cristiano di Flora

Debugging issues in Java programming are the focus of this challenging work. The book is targeted toward advanced Java programmers, because only experienced programmers will be able to effectively extract the huge added value of this work. However, less experienced programmers may learn a great deal by reading this work from a different perspective. Two principal parts make up the book. The first part presents fundamentals of the theory of debugging, pointing out the crucial role of debugging into the lifecycle of a software product. This short software engineering essay is really just a prelude to the more interesting material covered later. The first part of the book does not leverage the knowledge of real "software-engineered" programmers, and the second part is therefore far more interesting. Allen presents units of reusable "knowledge" for debugging Java applications (namely, the so-called "bug patterns"). These patterns can provide experienced programmers with a useful source for reasoning about their own source-code, and for leveraging their (often) unstable "daughters" into much more engineered and reliable products. Allen provides the readers with many guidelines to prevent recurring bug patterns in Java programming. The "What We've Learned" sections, along the notes on cures and preventions, are the most interesting elements of each chapter. I recommend this book to anyone looking to develop high quality Java-based applications, or seeking to improve the quality of an existing one. Online Computing Reviews Service

Access critical reviews of Computing literature here

Become a reviewer for Computing Reviews.

Please enable JavaScript to view thecomments powered by Disqus.

Recommendations