It’s all about bugs, right? So what are they?

The previous blog post had a number of definitions of software testing in it that focus on testing having bug finding as a purpose. As such this is not so strange since many people see finding or rather calling out bugs is the most visible part of software testing. Whether you agree with this or not one thing to me seems certain bugs are an important subject in software testing. This post then is all about bugs or rather it is about, the many definitions of (software) bugs.

  • “This thing gives out and then that. ‘Bug’—as such little faults and difficulties are called—show themselves, and months of anxious watching, study, and labor are requisite before commercial success—or failure—is certainly reached.” Edison letter to Pushkas [Edison, 1878]
  • “A software error is present when the program does not do what its end user reasonably expects it to do” Myers, 1976, p. 6 The art of software testing [1976]
  • “There can never be an absolute definition for bugs, nor an absolute determination of their existence. The extent to which a program has bugs is measured by the extent to which it fails to be useful. This is a fundamentally human measure” Beizer, p. 12). Software Systems and Quality Assurance [1984]
  • Fault: “An incorrect step, process, or data definition in a computer program. Note: This definition is used primarily by the fault tolerance discipline. In common usage, the terms ‘error’ and ‘bug’ are used to express this meaning.”
    Failure: “The inability of a system or component to perform its required functions within specified performance requirements. Note: The fault tolerance discipline distinguishes between a human action (a mistake), its manifestation (a hardware or software fault), the result of the fault ( a failure), and the amount by which the result is incorrect.” IEEE Standard 610.12-1990 [1990]
  • “A mismatch between the program and its specification is an error in the program if and only if the specification exists and is correct.” Kaner, Falk and Nguyen, Testing Computer Software [1993]
  • “Defect. Any state of unfitness for use, or nonconformance to specification.
    Error. (1) The difference between a computed, observed, or measured value and the true, specified, or theoretically correct value or condition. (2) An incorrect step, process, or data definition. Often called a bug. (3) An incorrect result. (4) A human action that produces an incorrect result. Note: One distinction assigns definition (1) to error, definition (2) to fault, definition (3) to failure, and definition (4) to mistake. Fault. An incorrect step, process, or data definition in a computer program. See also: error. Failure. Discrepancy between the external results of a program’s operation and the software product requirements. A software failure is evidence of the existence of a fault in the software.” Software Error Analysis, NIST [1993]
  • “A software defect is a “material breach” of the contract for sale or license of the software if it is so serious that the customer can justifiably demand a fix or can cancel the contract, return the software, and demand a refund.” Kaner, Software QA Magazine  [1996]
  • “The difference between the actual test result and the expected result can indicate a software product defect” Koomen and Pol, Test Process Improvement [1999]
  • “An observed difference between an expectation (prediction) and its actual outcome. A finding can be made on different objects, such as the test base (upon intake), while testing the system, on the test infrastructure, etc.” (translation) Pol, Teunissen, van Veenendaal, Testen volgens TMap 2e druk [2000]
  • “An error is clearly present if a program does not do what it is supposed to do, but errors are also present if a program does what it is not supposed to do.” Meyer, The art of software testing (2nd edition) [2004]
  • “A generic term that can refer to either a fault (cause) or a failure (effect). (IEEE 982.1-2005 IEEE Standard Dictionary of Measures of the Software Aspects of Dependability, 2.1) Example: (1) omissions and imperfections found during early life cycle phases and (2) faults contained in software sufficiently mature for test or operation” [2005]
  • “A bug, also referred to as a software bug, is an error or flaw in a computer program that may prevent it from working correctly or produce an incorrect or unintended result.” The Linux Information Project [2005]
  • “A defect (fault) is the result of an error residing in the code or document.”Broekman, van der Aalst, Vroon and Koomen, TMap Next for result driven testing [2006]
  • “A bug is anything about the program that threatens its value.” Bach and Bolton, Rapid Software Testing [2007]
  • Anything that causes an unnecessary or unreasonable reduction of the quality of a software product. BBST Bug Advocacy [2008]
  • “Defects are observations that the test results deviate from expectations” Bouman, SmarTEST [2008]
  • “A finding is an observed difference between an expectation or prediction and the actual outcome” Van der Aalst, Baarda, Roodenrijs, Vink and Visser, TMap NEXT Business Driven Test Management [2008]
  • “something that went wrong,” Alan Page. Ken Johnston. Bj Rollison, How we test software at Microsoft [2009]
  • “Situation that may cause errors to occur in an object” (ISO/IEC 10746-2:2009 Information technology — Open Distributed Processing — Reference Model: Foundations, 13.6.3) [2009]
  • Imperfection or deficiency in a work product where that work product does not meet its requirements or specifications and needs to be either repaired or replaced (IEEE 1044-2009 IEEE Standard Classification for Software Anomalies, 2) [2009]
  • An attribute of a software product that reduces its value to a favored stakeholder or increases its value to a disfavored stakeholder without a sufficiently large countervailing benefit. BBST Foundations [2010]
  • A software error is the failure to comply with an assured characteristic (translation)
    Ein Softwarefehler ist die Nichterfuellung einer zugesicherten Eigenschaft (eigenschaftsbezogene Fehlerdefinition). Basiswissen Software Testen [Spillner 2010]
  • A product has an error if it does not provide the security that when, taking into account all circumstances, in particular its performance, it can be used as reasonably can be legitimately expected, at the timing in which it was placed on the market. (translation) Ein produkt hat einen Fehler, wenn es nicht die Sicherheit bietet, die unter Berücksichtigung aller Umstande, ins besondere seiner Darbietung, des Gebrauchs, mit dem billigerweise gerechnet werden kann, des Zeitpunktes, in dem es in den Verkehr gebracht wurde, berechtigterweise erwartet werden kann [BGB01, ProdukthaftungsG. par. 3] (risikobesogene Fehlerdefinition). Basiswissen Software Testen [Spillner 2010]
  • Defect in a hardware device or component (ISO/IEC/IEEE 24765:2010 Systems and software engineering–Vocabulary) [2010]
  • Manifestation of an error in software (ISO/IEC/IEEE 24765:2010 Systems and software engineering–Vocabulary) [2010]
  • A Software Defect / Bug is a condition in a software product which does not meet a software requirement (as stated in the requirement specifications) or end-user expectations (which may not be specified but are reasonable). Software Testing Fundamentals [2010]
  • Incorrect step, process, or data definition in a computer program (ISO/IEC 25040:2011 Systems and software engineering–Systems and software Quality Requirements and Evaluation (SQuaRE)–Evaluation process, 4.27) [2011]
  • Defect in a system or a representation of a system that if executed/activated could potentially result in an error (ISO/IEC 15026-1:2013 Systems and software engineering–Systems and software assurance–Part 1: Concepts and vocabulary, 3.4.5) [2013]
  • Software bugs can originate from every step in translation from natural language, when:
    • the Syntax-rules were not followed
    • the translation falsified the Semantics, or
    • if the Pragmatics are unclear
      Software-Fehlertoleranz und Zuverlässigkeit [2013]
  • A software bug is an error, flaw, failure, or fault in a computer program or system that causes it to produce an incorrect or unexpected result, or to behave in unintended ways. Wikipedia [2015]
  • “the people who wrote the program told the computer to do something it couldn’t do”. Practical Programming [Gries, Campbell, Montojo 2015]
  • An imperfection or deficiency in a project component where that component does not meet its requirements or specifications and needs to be either repaired or replaced (A Guide to the Project Management Body of Knowledge (PMBOK(R) Guide) — Fifth Edition)
  • A software bug is a problem causing a program to crash or produce invalid output. Techopedia

What is software testing?

Over time the definitions of software testing and the ideas behind it have changed.
This post brings together an expanding collection of testing definitions in chronological order and thus provide an overview on changing views. Views that are based on the changes in computer and software development one would expect to be outdated but often still are in use today.

  • “How would we know a program exhibits intelligence?
    Alan Turing [1950]
  • “Make sure the program runs” and “Make sure the program solves the problem”
    Dan McCracken; Digital Computer Programming [1957]
  • “Errors plague us, but hidden errors make our job impossible. One of our recurring problems lies not in finding errors but in not finding errors. We must be alert for them; we can never be complacent about our results.”
    Herbert D. Leeds and Gerald M. Weinberg, [1961]
  • “Testing is the process of executing a program with the intent of finding errors.”
    Glenford J. Meyers; The art of software testing [1979]
  • “Test means execution, or set of executions, of the program for the purpose of measuring its performance. That a program was executed with no evidence of error is no proof that it contains no errors; program errors are sensitive to the specifics of the data being processed.” “The goal of testing ought to be the uncovering of defects within the program.”
    Robert Dunn and Richard Ullman, Quality Assurance for Computer Software, [1982]
  • “Testing is any activity aimed at evaluating an attribute of a program or system. Testing is the measurement of software quality.”
    Bill Hetzel, The Complete Guide to Software Testing [1983]
  • “Testing is the act of executing tests. Tests are designed and then executed to demonstrate correspondence between an element and its specification. There can be no testing without specifications of intentions.”
    Boris Beizer, Software System Testing and Quality Assurance [1984]
  • “The Testing stage involves full-scale use of the program in a live environment. It is here that the software and hardware are shaken down, anomalies of behavior are eliminated, and the documentation is updated to reflect final behavior. The testing must be as thorough as possible. The use of adversary roles at this stage is an extremely valuable tool because it ensures that the system works in as many circumstances as possible.”
    Henry Legard, Software Engineering Concepts: Volume 1 [1987]
  • “The purpose of testing a program is to find problems in it”
    Cem Kaner, Jack Falk, Hung Quoc Nguyen; Testing Computer Software [1988]
  • “The process of operating a system or component under specified conditions, observing or recording the results, and making an evaluation of some aspect of the system or component.”
    The 1990 IEEE Standard Glossary of Software Engineering Terminology [1990]
  • “Testing is the execution of software to determine where if functions incorrectly.”
    Robert L. Glass, Building Quality Software [1992]
  • “Testing helps detect defects that have escaped detection in the preceding phases of development. Here again, the key byproduct of testing is useful information about the number of and types of defects found in testing. Armed with this data, teams can begin to identify the root causes of these defects and eliminate them from the earlier phases of the software life cycle.”
    Lowell Jay Arthur, Improving Software Quality: An Insider’s Guide to TQM [1993]
  • “[Unit] Testing is a hard activity for most developers to swallow for several reasons: Testing’s goal runs counter to the goals of other development activities. The goal is to find errors. A successful test is one that breaks the software. … Testing can never prove the absence of errors — only their presence. … Testing by itself does not improve software quality. … Testing requires you to assume that you’ll find errors in your code. …”
    Steve McConnell, Code Complete: A Practical Handbook of Software Construction [1993]
  • “Testing is an unnecessary and unproductive activity if its sole purpose is to validate that the specifications were implemented as written. … testing as performed in most organizations is a process designed to compensate for an ineffective software development process. It is unrealistic to develop software and not test it. The perfect development process does not exist …”
    William Perry, Effective Methods for Software Testing [1995]
  • “A tester is given a false statement (‘the system works’) and has the job of selecting, from an infinite number of possibilities, an input that contradicts the statement. … [You want to find] the right counterexample with a minimum of wasted effort.”
    Brian Marick, The Craft of Software Testing: Subsystem Testing [1995]
  • “Testing is obviously concerned with errors, faults, failures, and incidents. A test is the act of exercising software with test cases. There are two distinct goals of a test: either to find failures, or to demonstrate correct execution.”
    Paul C. Jorgensen, Software Testing: A Craftsman’s Approach [1995]
  • “The penultimate objective of testing is to gather management information.”
    Boris Beizer, Black Box Software Testing: Techniques for Functional Testing of Software and Systems [1995]
  • “The most common quality-assurance practice is undoubtedly execution testing, finding errors by executing a program and seeing what it does.”
    Steve McConnell, Rapid Development: Taming Wild Software Schedules [1996]
  • “Software testing is the action of carrying out one or more tests, where a test is a technical operation that determines one or more characteristics of a given software element or system, according to a specified procedure. The means of software testing is the hardware and/or software and the procedures for its use, including the executable test suite used to carry out the testing.”
    NIST [1997]
  • “Software must be tested to have confidence that it will work as it should in its intended environment. Software testing needs to be effective at finding any defects which are there, but it should also be efficient, performing the tests as quickly and cheaply as possible.”
    Mark Fewster and Dorothy Graham, Software Test Automation: Effective use of test execution tools [1999]
  • “Testing is the process by which we explore and understand the status of the benefits and the risk associated with release of a software system.”
    James Bach, James Bach on Risk-Based Testing, STQE Magazine [1999]
  • “Testing is a process of planning, preparing, executing and evaluating, with the purpose to determine the attributes of an information system and to show the differences between its actual and demanded state” Pol, Teunissen, van Veenendaal, Testen volgens TMap 2e druk [2000]
  • “Software testing is a difficult endeavor that requires education, skill, practice, and experience. Building good testing strategies requires merging many different disciplines and techniques.”
    James A. Whittaker, IEEE Software (Vol 17, No 1) [2000]
  • “Software testing is the process of applying metrics to determine product quality. Software testing is the dynamic execution of software and the comparison of the results of that execution against a set of pre-determined criteria.”
    NIST The Economic Impacts of Inadequate Infrastructure for Software Testing [2002]
  • “Testing is done to find information. Critical decisions about the project or the product are made on the basis of that information.”
    Cem Kaner, James Bach, Bret Pettichord,
    Lessons Learned In Software Testing: A Context-Driven Approach [2002]
  • “Testing is a concurrent lifecycle process of engineering, using and maintaining testware in order to measure and improve the quality of the software being tested.”
    – Rick Craig and Stefan Jaskiel, Systematic Software Testing [2002]
  • “A software tester’s job is to test software, find bugs, and report them so that they can be fixed. An effective software tester focuses on the software product itself and gathers empirical information regarding what it does and doesn’t do. This is a big job all by itself. The challenge is to provide accurate, comprehensive, and timely information, so managers can make informed decisions.”
    Brett Pettichord, Don’t Become the Quality Police, StickyMinds.com [2002]
  • “Software testing is a process of analyzing or operating software for the purpose of finding bugs.”
    – Robert Culbertson, Chris Brown, and Gary Cobb, Rapid Testing [2002]
  • “How do you test your software? Write an automated test.
    Test is a verb meaning ‘to evaluate’. No software engineers release even the tiniest change without testing, except the very confident and the very sloppy. … Although you may test your changes, testing changes is not the same as having tests. Test is also a noun, ‘a procedure leading to acceptance or rejection’. Why does test the noun, a procedure that runs automatically, feel different from test the verb, such as poking a few buttons and looking at answers on the screen?”
    – Kent Beck, Test-Driven Development By Example [2003]
  • “My conclusion is that testing is an intellectual endeavor and not part of arts and crafts. So testing is not something anyone masters. Once you stop learning, your knowledge becomes obsolete very fast. Thus, to realize your testing potential, you must commit to continuous learning.”
    James A. Whittaker, How to Break Software: A Practical Guide to Testing [2003]
  • “All software has bugs. It’s a fact of life. So the goal of finding and removing all defects in a software product is a losing proposition and a dangerous objective for a test team, because such a goal can divert the test team’s attention from what is really important. … [The goal of a test team] is to ensure that among the defects found are all of those that will disrupt real production environments; in other words, to find the defects that matter.”
    Scott Loveland, Geoffrey Miller, Richard Prewitt, and Michael Shannon,
    Software Testing Techniques: Finding the Defects that Matter [2004]
  • “Software Testing [is] The act of confirming that software design specifications have been effectively fulfilled and attempting to find software faults during execution of the software.”
    Thomas H. Faris, Safe And Sound Software: Creating an Efficient and Effective Quality System [2006]
  • “Checking is the inspection of intermediate products and development processes, or verification. These all the activities directed to answering the question: Is the building done rightly?
    Testing is the inspection of end products, or validation. Is the product valid against its demand? Is the right thing build?” (translation) Koomen, Pol Test Process Improvement [2006]
  • “Software testing is a process where we check a behavior we observe against a specified behavior the business expects. … in software testing, the tester should know what behavior to expect as defined by the business requirements. We agree on this defined, expected behavior and any user can observe this behavior.”
    Andreas Golze, Charlie Li, Shel Prince, Optimize Quality for Business Outcomes: A Practical Approach to Software Testing [2006]
  • “Testing is a process of gathering information by making observations and comparing them to expectations.” “A test is an experiment designed to reveal information, or answer a specific question, about the software or system.”
    Dale Emery and Elizabeth Hendrickson [2007]
  • “software testing as a process of technical investigation, an empirical study of the product under test with the goal of exposing quality-relating information about it. (Validation and verification both fit within this definition.)”
    LAWST [2007]
  • “[Testing is]  An empirical, technical investigation conducted to provide stakeholders with information about the quality of the product under test.  A process focused on empirically questioning a product or service about its quality.”
    Cem Kaner [2007]
  • “An empirical, technical investigation conducted to provide stakeholders with information about the quality of the product OR SERVICE under test.”
    Scott Barber [2007]
  • “Testing is… an infinite process of comparing the invisible to the ambiguous in order to avoid the unthinkable happening to the anonymous”
    Jon Bach, Telling Your Testing Story, SEASPIN [2008]
  • “Test:(verb) to critically evaluate; to determine the presence, quality, or truth of something; to conduct a trial.” – used by Paul Gerrard, Test axioms-definitions,  http://testaxioms.com/index.php?q=node/3 [2008]
  • “Testing is strategic tool for risk control”
    Egbert Bouman, SmarTEST [2008]
  • “The test process has to produce information about errors found and the degree to which the quality has been improved by solving them. In turn, the tests have to indicate whether the modified system responds to the reason that led to the change, and if it contributes to the business requirements.” de Grood, TestGoal [2008]
  • “Testing is a process that provides insight into, and advices about, quality and its related risks” Van der Aalst, Baarda, Roodenrijs, Vink and Visser, TMap NEXT Business Driven Test Management [2008]
  • “The process consisting of all life cycle activities, both static and dynamic, concerned with planning, preparation and evaluation of software products and related work products to determine that they satisfy specified requirements, to demonstrate that they are fit for purpose and to detect defects. ”
    Jeanne Hofmans and Erwin Pasmans, Quality Level Management [2012]
  • “interact with the software or system, observe its actual behavior, and compare that to your expectations”
    Elisabeth Hendrickson; ‘Explore It! [2013]
  • “Testing is the process of evaluating a product by learning about it through exploration and experimentation, which includes to some degree: questioning, study, modeling, observation, inference, etc.”
    James Bach, Michael Bolton [2013] http://www.satisfice.com/blog/archives/856
  • “Software testing is an investigation conducted to provide stakeholders with information about the quality of the product or service under test. The information is compared against specifications, business requirements, competitive products, past versions of this product, user expectations, industry standards, applicable laws and other criteria.”
    Undisclosed company policy [2015]
  • “Professional, sophisticated software testing is an approach that lets people get the information that they need at the time they need it, in order to make timely decisions.” Trish Khoo, Rock solid software without hiring an army, [June 2016]
  • “Testing is the pursuit of actual or potential incongruity”
    James Thomas [2016] http://qahiccupps.blogspot.nl/2016/11/the-anatomy-of-definition-of-testing.html

Undated:

  • Context-driven testers choose their testing objectives, techniques, and deliverables (including test documentation) by looking first to the details of the specific situation, including the desires of the stakeholders who commissioned the testing. The essence of context-driven testing is project-appropriate application of skill and judgment. The Context-Driven School of testing places this approach to testing within a humanistic social and ethical framework.
    Ultimately, context-driven testing is about doing the best we can with what we get. Rather than trying to apply “best practices,” we accept that very different practices (even different definitions of common testing terms) will work best under different circumstances.
    Cem Kaner, James Bach
  • “Software testing is a process of executing a program or application with the intent of finding the software bugs” and “the process of validating and verifying that a software program or application or product: Meets the business and technical requirements that guided it’s design and development; Works as expected; Can be implemented with the same characteristic”
    ISTQB Foundation Exam

Unknown origin:

  • “Testing is finding out how well something works”
  • “Testing is the process of evaluating a system or its component(s) with the intent to find out that whether it satisfies the specified requirements or not”
  • “Software testing is the process of evaluating a software item to detect differences between given input and expected output”
  • “Software testing is a process that should be done during the development process”