Create a Typographical Art Piece With Their Favorite Quotes

Mistake, flaw, failure, or fault in a computer programme or system

A software bug is an error, flaw or fault in computer software that causes it to produce an incorrect or unexpected result, or to bear in unintended ways. The process of finding and correcting bugs is termed "debugging" and frequently uses formal techniques or tools to pinpoint bugs. Since the 1950s some reckoner systems have been designed to deter, detect or motorcar-correct various estimator bugs during operations.

Most bugs arise from mistakes and errors made in either a program'southward design or its source code, or in components and operating systems used past such programs. A programme with many, or serious, bugs is said to be buggy. Bugs can trigger errors that may have ripple effects. Bugs may have subtle furnishings, or cause a program to crash, or freeze the computer. Other bugs authorize as security bugs and might, for example, enable a malicious user to bypass access controls in club to obtain unauthorized privileges.^[i]

Some software bugs have been linked to disasters. Bugs in code that controlled the Therac-25 radiation therapy machine were straight responsible for patient deaths in the 1980s. In 1996, the European Space Agency'south US$i billion prototype Ariane 5 rocket was destroyed less than a minute after launch due to a problems in the on-board guidance reckoner plan.^[2] In 1994, an RAF Chinook helicopter crashed, killing 29; this was initially blamed on pilot mistake, only was later thought to take been acquired past a software issues in the engine-control computer.^[3] Buggy software caused the early on 21st century British Post Part scandal, the nearly widespread miscarriage of justice in British legal history.^[4]

In 2002, a written report deputed past the United states Section of Commerce'south National Plant of Standards and Technology concluded that "software bugs, or errors, are so prevalent and so detrimental that they price the US economy an estimated $59 billion annually, or nigh 0.6 pct of the gross domestic product".^[v]

History [edit]

The Eye English word bugge is the ground for the terms "bugbear" and "bugaboo" as terms used for a monster.^[half-dozen]

The term "bug" to describe defects has been a office of engineering jargon since the 1870s^[seven] and predates electronics and computers; it may have originally been used in hardware engineering to describe mechanical malfunctions. For example, Thomas Edison wrote in a letter to an acquaintance in 1878:^[viii]

... difficulties ascend—this thing gives out and [information technology is] then that "Bugs"—as such little faults and difficulties are called—prove themselves^[9]

Baffle Ball, the first mechanical pinball game, was advertised as being "free of bugs" in 1931.^[ten] Issues with military gear during World State of war Ii were referred to as bugs (or glitches).^[11] In a volume published in 1942, Louise Dickinson Rich, speaking of a powered ice cutting motorcar, said, "Ice sawing was suspended until the creator could be brought in to accept the bugs out of his darling."^[12]

Isaac Asimov used the term "bug" to relate to issues with a robot in his short story "Catch That Rabbit", published in 1944.

A page from the Harvard Marker II electromechanical computer's log, featuring a dead moth that was removed from the device.

The term "bug" was used in an account by computer pioneer Grace Hopper, who publicized the cause of a malfunction in an early on electromechanical computer.^[13] A typical version of the story is:

In 1946, when Hopper was released from active duty, she joined the Harvard Faculty at the Ciphering Laboratory where she continued her piece of work on the Marker Ii and Marking Iii. Operators traced an error in the Mark II to a moth trapped in a relay, coining the term problems. This bug was advisedly removed and taped to the log book. Stemming from the showtime bug, today nosotros call errors or glitches in a program a issues.^[xiv]

Hopper was non nowadays when the bug was plant, but it became i of her favorite stories.^[15] The date in the log book was September 9, 1947.^{[16] [17] [18]} The operators who found information technology, including William "Bill" Burke, later on of the Naval Weapons Laboratory, Dahlgren, Virginia,^[19] were familiar with the technology term and amusedly kept the insect with the notation "First actual case of bug being found." This log book, complete with fastened moth, is office of the collection of the Smithsonian National Museum of American History.^[17]

The related term "debug" also appears to predate its usage in computing: the Oxford English Dictionary 's etymology of the word contains an testament from 1945, in the context of aircraft engines.^[20]

The concept that software might contain errors dates back to Ada Lovelace'south 1843 notes on the analytical engine, in which she speaks of the possibility of program "cards" for Charles Babbage's analytical engine being erroneous:

... an analysing procedure must as have been performed in order to furnish the Analytical Engine with the necessary operative data; and that herein may also lie a possible source of mistake. Granted that the actual mechanism is unerring in its processes, the cards may give it wrong orders.

"Bugs in the System" report [edit]

The Open Applied science Institute, run by the group, New America,^[21] released a written report "Bugs in the Arrangement" in Baronial 2016 stating that U.Due south. policymakers should brand reforms to help researchers identify and address software bugs. The study "highlights the need for reform in the field of software vulnerability discovery and disclosure."^[22] 1 of the report's authors said that Congress has not done plenty to address cyber software vulnerability, even though Congress has passed a number of bills to gainsay the larger upshot of cyber security.^[22]

Government researchers, companies, and cyber security experts are the people who typically discover software flaws. The study calls for reforming computer crime and copyright laws.^[22]

The Calculator Fraud and Abuse Act, the Digital Millennium Copyright Human action and the Electronic Communications Privacy Act criminalize and create civil penalties for actions that security researchers routinely engage in while conducting legitimate security enquiry, the report said.^[22]

Terminology [edit]

While the use of the term "problems" to draw software errors is mutual, many have suggested that it should be abased. One argument is that the discussion "bug" is divorced from a sense that a human existence acquired the problem, and instead implies that the defect arose on its own, leading to a push to abandon the term "issues" in favor of terms such every bit "defect", with limited success.^[23] Since the 1970s Gary Kildall somewhat humorously suggested to use the term "blunder".^{[24] [25]}

In software engineering, error metamorphism (from Greek meta = "change", morph = "course") refers to the evolution of a defect in the terminal stage of software deployment. Transformation of a "mistake" committed by an analyst in the early stages of the software development lifecycle, which leads to a "defect" in the terminal stage of the wheel has been called 'mistake metamorphism'.^[26]

Different stages of a "mistake" in the unabridged cycle may be described as "mistakes", "anomalies", "faults", "failures", "errors", "exceptions", "crashes", "glitches", "bugs", "defects", "incidents", or "side effects".^[26]

Prevention [edit]

The software manufacture has put much effort into reducing bug counts.^{[27] [28]} These include:

Typographical errors [edit]

Bugs usually appear when the programmer makes a logic error. Diverse innovations in programming style and defensive programming are designed to make these bugs less likely, or easier to spot. Some typos, specially of symbols or logical/mathematical operators, allow the program to operate incorrectly, while others such every bit a missing symbol or misspelled proper noun may prevent the program from operating. Compiled languages can reveal some typos when the source code is compiled.

Evolution methodologies [edit]

Several schemes help managing developer activity so that fewer bugs are produced. Software engineering (which addresses software design issues every bit well) applies many techniques to forestall defects. For case, formal program specifications state the exact behavior of programs so that design bugs may be eliminated. Unfortunately, formal specifications are impractical for annihilation but the shortest programs, considering of problems of combinatorial explosion and indeterminacy.

Unit testing involves writing a test for every function (unit) that a programme is to perform.

In examination-driven development unit of measurement tests are written before the code and the code is not considered complete until all tests complete successfully.

Agile software development involves frequent software releases with relatively small-scale changes. Defects are revealed by user feedback.

Open source evolution allows anyone to examine source lawmaking. A school of thought popularized past Eric S. Raymond as Linus's law says that popular open-source software has more run a risk of having few or no bugs than other software, because "given enough eyeballs, all bugs are shallow".^[29] This assertion has been disputed, however: computer security specialist Elias Levy wrote that "it is easy to hide vulnerabilities in complex, niggling understood and undocumented source code," considering, "even if people are reviewing the code, that doesn't mean they're qualified to do and so."^[thirty] An example of an open up-source software bug was the 2008 OpenSSL vulnerability in Debian.

Programming linguistic communication back up [edit]

Programming languages include features to help prevent bugs, such every bit static type systems, restricted namespaces and modular programming. For example, when a programmer writes (pseudocode) Allow REAL_VALUE PI = "THREE AND A Chip", although this may exist syntactically correct, the code fails a type bank check. Compiled languages catch this without having to run the programme. Interpreted languages take hold of such errors at runtime. Some languages deliberately exclude features that easily pb to bugs, at the expense of slower performance: the general principle existence that, it is almost always better to write simpler, slower code than inscrutable code that runs slightly faster, particularly considering that maintenance toll is substantial. For example, the Java programming language does not support pointer arithmetic; implementations of some languages such as Pascal and scripting languages ofttimes have runtime bounds checking of arrays, at least in a debugging build.

Code analysis [edit]

Tools for code assay assist developers by inspecting the program text across the compiler's capabilities to spot potential problems. Although in full general the problem of finding all programming errors given a specification is not solvable (encounter halting trouble), these tools exploit the fact that human programmers tend to make certain kinds of uncomplicated mistakes often when writing software.

Instrumentation [edit]

Tools to monitor the operation of the software every bit it is running, either specifically to detect problems such every bit bottlenecks or to give balls as to correct working, may be embedded in the code explicitly (maybe as simple as a argument saying Print "I AM Here"), or provided every bit tools. Information technology is oft a surprise to observe where most of the time is taken by a piece of code, and this removal of assumptions might cause the code to be rewritten.

Testing [edit]

Software testers are people whose primary task is to find bugs, or write code to support testing. On some projects, more than resources may be spent on testing than in developing the plan.

Measurements during testing can provide an approximate of the number of likely bugs remaining; this becomes more than reliable the longer a product is tested and developed.^{[ citation needed ]}

Debugging [edit]

The typical bug history (GNU Classpath project data). A new bug submitted past the user is unconfirmed. Once information technology has been reproduced by a developer, it is a confirmed problems. The confirmed bugs are subsequently fixed. Bugs belonging to other categories (unreproducible, will not exist fixed, etc.) are ordinarily in the minority

Finding and fixing bugs, or debugging, is a major function of computer programming. Maurice Wilkes, an early calculating pioneer, described his realization in the late 1940s that much of the rest of his life would be spent finding mistakes in his ain programs.^[31]

Usually, the most difficult function of debugging is finding the problems. Once information technology is found, correcting information technology is unremarkably relatively easy. Programs known as debuggers assist programmers locate bugs by executing code line by line, watching variable values, and other features to observe program beliefs. Without a debugger, code may be added so that messages or values may exist written to a panel or to a window or log file to trace program execution or show values.

Even so, even with the assistance of a debugger, locating bugs is something of an art. It is not uncommon for a problems in one section of a programme to crusade failures in a completely different department,^{[ citation needed ]} thus making it specially difficult to rail (for case, an mistake in a graphics rendering routine causing a file I/O routine to fail), in an obviously unrelated part of the system.

Sometimes, a bug is not an isolated flaw, but represents an fault of thinking or planning on the office of the programmer. Such logic errors require a department of the plan to be overhauled or rewritten. Equally a part of lawmaking review, stepping through the code and imagining or transcribing the execution process may oftentimes detect errors without e'er reproducing the bug as such.

More than typically, the first step in locating a bug is to reproduce it reliably. In one case the bug is reproducible, the programmer may use a debugger or other tool while reproducing the error to find the point at which the program went astray.

Some bugs are revealed by inputs that may be difficult for the programmer to re-create. One cause of the Therac-25 radiation machine deaths was a bug (specifically, a race condition) that occurred only when the machine operator very chop-chop entered a handling plan; it took days of do to get able to do this, and then the issues did non manifest in testing or when the manufacturer attempted to duplicate it. Other bugs may finish occurring whenever the setup is augmented to help find the bug, such every bit running the plan with a debugger; these are chosen heisenbugs (humorously named afterward the Heisenberg dubiousness principle).

Since the 1990s, peculiarly following the Ariane 5 Flight 501 disaster, involvement in automatic aids to debugging rose, such every bit static lawmaking analysis by abstract interpretation.^[32]

Some classes of bugs have cypher to do with the code. Faulty documentation or hardware may lead to problems in system utilise, even though the code matches the documentation. In some cases, changes to the code eliminate the problem even though the lawmaking then no longer matches the documentation. Embedded systems ofttimes piece of work around hardware bugs, since to make a new version of a ROM is much cheaper than remanufacturing the hardware, especially if they are commodity items.

Criterion of bugs [edit]

To facilitate reproducible research on testing and debugging, researchers utilise curated benchmarks of bugs:

• the Siemens benchmark
• ManyBugs^[33] is a benchmark of 185 C bugs in 9 open-source programs.
• Defects4J^[34] is a benchmark of 341 Java bugs from 5 open-source projects. It contains the corresponding patches, which cover a multifariousness of patch type.^[35]
• BEARS^[36] is a benchmark of continuous integration build failures focusing on test failures. It has been created by monitoring builds from open-source projects on Travis CI.

Bug management [edit]

Bug management includes the process of documenting, categorizing, assigning, reproducing, correcting and releasing the corrected code. Proposed changes to software – bugs as well as enhancement requests and even entire releases – are commonly tracked and managed using problems tracking systems or upshot tracking systems.^[37] The items added may be called defects, tickets, problems, or, post-obit the active development prototype, stories and epics. Categories may be objective, subjective or a combination, such as version number, surface area of the software, severity and priority, as well equally what type of issue it is, such as a feature request or a bug.

A bug triage reviews bugs and decides whether and when to fix them. The decision is based on the issues's priority, and factors such as project schedules. The triage is non meant to investigate the cause of bugs, but rather the cost of fixing them. The triage happens regularly, and goes through bugs opened or reopened since the previous meeting. The attendees of the triage process typically are the projection manager, development director, test managing director, build manager, and technical experts.^{[38] [39]}

Severity [edit]

Severity is the intensity of the bear on the issues has on system operation.^[40] This impact may be data loss, financial, loss of goodwill and wasted attempt. Severity levels are not standardized. Impacts differ across industry. A crash in a video game has a totally unlike bear upon than a crash in a web browser, or real time monitoring system. For case, issues severity levels might be "crash or hang", "no workaround" (meaning in that location is no fashion the customer can accomplish a given chore), "has workaround" (meaning the user can however accomplish the task), "visual defect" (for instance, a missing image or displaced push button or grade element), or "documentation error". Some software publishers utilise more qualified severities such every bit "critical", "loftier", "low", "blocker" or "picayune".^[41] The severity of a bug may be a separate category to its priority for fixing, and the two may be quantified and managed separately.

Priority [edit]

Priority controls where a bug falls on the listing of planned changes. The priority is decided past each software producer. Priorities may be numerical, such as 1 through 5, or named, such as "critical", "loftier", "low", or "deferred". These rating scales may be similar or fifty-fifty identical to severity ratings, but are evaluated as a combination of the issues's severity with its estimated effort to fix; a problems with low severity just easy to fix may get a higher priority than a bug with moderate severity that requires excessive attempt to fix. Priority ratings may be aligned with product releases, such every bit "critical" priority indicating all the bugs that must be stock-still before the next software release.

Software releases [edit]

It is common exercise to release software with known, depression-priority bugs. Bugs of sufficiently high priority may warrant a special release of part of the code containing simply modules with those fixes. These are known every bit patches. Most releases include a mixture of behavior changes and multiple issues fixes. Releases that emphasize bug fixes are known as maintenance releases, to differentiate it from major releases that emphasize feature additions or changes.

Reasons that a software publisher opts not to patch or fifty-fifty fix a detail bug include:

• A deadline must be met and resource are bereft to fix all bugs by the deadline.^[42]
• The problems is already fixed in an upcoming release, and it is not of high priority.
• The changes required to set up the bug are too costly or touch on besides many other components, requiring a major testing activity.
• Information technology may be suspected, or known, that some users are relying on the existing buggy behavior; a proposed prepare may introduce a breaking change.
• The problem is in an area that will be obsolete with an upcoming release; fixing it is unnecessary.
• "It's non a bug, it'due south a feature".^[43] A misunderstanding has arisen between expected and perceived behavior or undocumented characteristic.

Types [edit]

In software development projects, a "error" or "fault" may be introduced at any stage. Bugs arise from oversights or misunderstandings made by a software team during specification, design, coding, data entry or documentation. For example, a relatively simple plan to alphabetize a list of words, the design might fail to consider what should happen when a word contains a hyphen. Or when converting an abstract blueprint into lawmaking, the coder might inadvertently create an off-by-one error which can be a "<" where "<=" was intended, and fail to sort the final word in a list.

Another category of bug is chosen a race condition that may occur when programs have multiple components executing at the same time. If the components collaborate in a different order than the developer intended, they could interfere with each other and cease the programme from completing its tasks. These bugs may exist difficult to discover or anticipate, since they may not occur during every execution of a program.

Conceptual errors are a programmer'due south misunderstanding of what the software must do. The resulting software may perform according to the developer's understanding, but not what is really needed. Other types:

Arithmetic [edit]

• Division by zero.
• Arithmetic overflow or underflow.
• Loss of arithmetic precision due to rounding or numerically unstable algorithms.

Logic [edit]

• Infinite loops and infinite recursion.
• Off-by-ane error, counting 1 also many or too few when looping.

Syntax [edit]

• Use of the incorrect operator, such as performing assignment instead of equality exam. For example, in some languages x=5 will set the value of x to v while x==5 volition check whether x is currently 5 or some other number. Interpreted languages allow such code to fail. Compiled languages can catch such errors earlier testing begins.

Resource [edit]

• Nothing pointer dereference.
• Using an uninitialized variable.
• Using an otherwise valid instruction on the wrong data type (see packed decimal/binary-coded decimal).
• Admission violations.
• Resources leaks, where a finite system resource (such as memory or file handles) become exhausted by repeated allocation without release.
• Buffer overflow, in which a programme tries to store information past the end of allocated storage. This may or may not pb to an access violation or storage violation. These are known as security bugs.
• Excessive recursion which—though logically valid—causes stack overflow.
• Apply-after-gratis error, where a pointer is used after the system has freed the memory it references.
• Double gratuitous error.

Multi-threading [edit]

• Deadlock, where task A cannot go on until task B finishes, simply at the same time, task B cannot continue until chore A finishes.
• Race status, where the computer does not perform tasks in the order the developer intended.
• Concurrency errors in critical sections, mutual exclusions and other features of concurrent processing. Time-of-bank check-to-time-of-use (TOCTOU) is a form of unprotected critical section.

Interfacing [edit]

• Wrong API usage.^[44]
• Incorrect protocol implementation.
• Incorrect hardware handling.
• Incorrect assumptions of a detail platform.
• Incompatible systems. A new API or communications protocol may seem to work when two systems use dissimilar versions, merely errors may occur when a part or characteristic implemented in one version is changed or missing in another. In production systems which must run continually, shutting downwardly the entire system for a major update may not be possible, such as in the telecommunication manufacture^[45] or the cyberspace.^{[46] [47] [48]} In this case, smaller segments of a big organisation are upgraded individually, to minimize disruption to a big network. However, some sections could be overlooked and not upgraded, and crusade compatibility errors which may be hard to find and repair.
• Incorrect lawmaking annotations^[49]

Teamworking [edit]

• Unpropagated updates; east.yard. developer changes "myAdd" but forgets to change "mySubtract", which uses the same algorithm. These errors are mitigated by the Don't Repeat Yourself philosophy.
• Comments out of appointment or incorrect: many programmers assume the comments accurately describe the code.
• Differences between documentation and product.

Implications [edit]

The amount and type of damage a software problems may crusade naturally affects conclusion-making, processes and policy regarding software quality. In applications such as homo spaceflight, aviation, nuclear power, health care, public send or automotive condom, since software flaws take the potential to cause homo injury or even death, such software volition have far more scrutiny and quality control than, for case, an online shopping website. In applications such every bit cyberbanking, where software flaws have the potential to cause serious financial damage to a bank or its customers, quality control is likewise more important than, say, a photograph editing application. NASA'south Software Assurance Technology Centre managed to reduce the number of errors to fewer than 0.1 per 1000 lines of code (SLOC)^{[ citation needed ]} just this was non felt to be feasible for projects in the concern globe.

According to a NASA study on "Flight Software Complexity", "an exceptionally practiced software development process tin can keep defects down to as low as 1 defect per 10,000 lines of code."^[fifty]

Other than the damage caused by bugs, some of their cost is due to the effort invested in fixing them. In 1978, Lientz et al. showed that the median of projects invest 17 per cent of the evolution endeavour in bug fixing.^[51] In research in 2020 on GitHub repositories showed the median is xx%.^[52]

Well-known bugs [edit]

A number of software bugs take become well-known, usually due to their severity: examples include various space and military aircraft crashes. Possibly the most famous issues is the Yr 2000 problem or Y2K bug, which acquired many programs written long before the transition from 19xx to 20xx dates to malfunction, for example treating a appointment such every bit "25 Dec 04" as being in 1904, displaying "19100" instead of "2000", and so on. A huge effort at the end of the 20th century resolved the nearly astringent problems, and in that location were no major consequences.

The 2012 stock trading disruption involved one such incompatibility between the onetime API and a new API.

In popular culture [edit]

• In both the 1968 novel 2001: A Space Odyssey and the corresponding 1968 film 2001: A Space Odyssey, a spaceship's onboard calculator, HAL 9000, attempts to impale all its crew members. In the follow-up 1982 novel, 2010: Odyssey Two, and the accompanying 1984 moving picture, 2010, it is revealed that this activeness was acquired by the computer having been programmed with two conflicting objectives: to fully disclose all its information, and to proceed the truthful purpose of the flight undercover from the crew; this conflict caused HAL to get paranoid and eventually homicidal.
• In the English version of the Nena 1983 song 99 Luftballons (99 Red Balloons) as a result of "bugs in the software", a release of a group of 99 red balloons are mistaken for an enemy nuclear missile launch, requiring an equivalent launch response, resulting in catastrophe.
• In the 1999 American comedy Office Space, 3 employees attempt (unsuccessfully) to exploit their visitor's preoccupation with the Y2K computer bug using a figurer virus that sends rounded-off fractions of a penny to their depository financial institution account—a long-known technique described as salami slicing.
• The 2004 novel The Bug, past Ellen Ullman, is virtually a developer'due south attempt to detect an elusive bug in a database awarding.^[53]
• The 2008 Canadian film Control Alt Delete is about a computer programmer at the stop of 1999 struggling to fix bugs at his visitor related to the yr 2000 trouble.

See also [edit]

• Anti-design
• Problems bounty program
• Glitch removal
• ISO/IEC 9126, which classifies a issues as either a defect or a nonconformity
• Orthogonal Defect Nomenclature
• Racetrack problem
• RISKS Assimilate
• Software defect indicator
• Software regression
• Software rot
• Automatic bug fixing

References [edit]

1. ^ Mittal, Varun; Aditya, Shivam (Jan 1, 2015). "Recent Developments in the Field of Problems Fixing". Procedia Information science. International Conference on Computer, Communication and Convergence (ICCC 2015). 48: 288–297. doi:10.1016/j.procs.2015.04.184. ISSN 1877-0509.
2. ^ "Ariane 501 - Presentation of Inquiry Lath report". world wide web.esa.int . Retrieved Jan 29, 2022.
3. ^ Prof. Simon Rogerson. "The Chinook Helicopter Disaster". Ccsr.cse.dmu.ac.uk. Archived from the original on July 17, 2012. Retrieved September 24, 2012.
4. ^ "Post Office scandal ruined lives, inquiry hears". BBC News. February xiv, 2022.
5. ^ "Software bugs toll US economic system dear". June x, 2009. Archived from the original on June 10, 2009. Retrieved September 24, 2012. {{cite web}}: CS1 maint: unfit URL (link)
6. ^ Computerworld staff (September 3, 2011). "Moth in the automobile: Debugging the origins of 'bug'". Computerworld. Archived from the original on August 25, 2015.
7. ^ "problems". Oxford English language Lexicon (Online ed.). Oxford University Printing. (Subscription or participating establishment membership required.) 5a
8. ^ "Did You Know? Edison Coined the Term "Issues"". Baronial 1, 2013. Retrieved July 19, 2019.
9. ^ Edison to Puskas, thirteen November 1878, Edison papers, Edison National Laboratory, U.Due south. National Park Service, West Orangish, Northward.J., cited in Hughes, Thomas Parke (1989). American Genesis: A Century of Invention and Technological Enthusiasm, 1870-1970. Penguin Books. p. 75. ISBN978-0-14-009741-two.
10. ^ "Baffle Ball". Cyberspace Pinball Database. (See image of advertisement in reference entry)
11. ^ "Modern Aircraft Carriers are Consequence of 20 Years of Smart Experimentation". Life. June 29, 1942. p. 25. Archived from the original on June 4, 2013. Retrieved Nov 17, 2011.
12. ^ Dickinson Rich, Louise (1942), We Took to the Forest, JB Lippincott Co, p. 93, LCCN 42024308, OCLC 405243, archived from the original on March 16, 2017.
13. ^ FCAT NRT Examination, Harcourt, March 18, 2008
14. ^ "Danis, Sharron Ann: "Rear Admiral Grace Murray Hopper"". ei.cs.vt.edu. February 16, 1997. Retrieved Jan 31, 2010.
15. ^ James S. Huggins. "First Computer Bug". Jamesshuggins.com. Archived from the original on August xvi, 2000. Retrieved September 24, 2012.
16. ^ "Issues Archived March 23, 2017, at the Wayback Machine", The Jargon File, ver. 4.4.vii. Retrieved June three, 2010.
17. ^ ^{a b} "Log Book With Estimator Bug Archived March 23, 2017, at the Wayback Machine", National Museum of American History, Smithsonian Establishment.
18. ^ "The Beginning "Computer Bug", Naval Historical Middle. Merely note the Harvard Mark II computer was not complete until the summertime of 1947.
19. ^ IEEE Annals of the History of Calculating, Vol 22 Issue 1, 2000
20. ^ Journal of the Regal Aeronautical Order. 49, 183/2, 1945 "It ranged ... through the stage of type test and flying exam and 'debugging' ..."
21. ^ Wilson, Andi; Schulman, Ross; Bankston, Kevin; Herr, Trey. "Bugs in the Arrangement" (PDF). Open up Policy Institute. Archived (PDF) from the original on September 21, 2016. Retrieved August 22, 2016.
22. ^ ^{a b c d} Rozens, Tracy (August 12, 2016). "Cyber reforms needed to strengthen software issues discovery and disclosure: New America report – Homeland Preparedness News". Retrieved Baronial 23, 2016.
23. ^ "News at SEI 1999 Archive". cmu.edu. Archived from the original on May 26, 2013.
24. ^ Shustek, Len (August two, 2016). "In His Own Words: Gary Kildall". Remarkable People. Computer History Museum. Archived from the original on December 17, 2016.
25. ^ Kildall, Gary Arlen (August 2, 2016) [1993]. Kildall, Scott; Kildall, Kristin (eds.). "Reckoner Connections: People, Places, and Events in the Evolution of the Personal Computer Industry" (Manuscript, part i). Kildall Family: fourteen–15. Archived from the original on November 17, 2016. Retrieved November 17, 2016.
26. ^ ^{a b} "Testing feel : te : the magazine for professional testers". Testing Experience. Germany: testingexperience: 42. March 2012. ISSN 1866-5705. (subscription required)
27. ^ Huizinga, Dorota; Kolawa, Adam (2007). Automated Defect Prevention: Best Practices in Software Management. Wiley-IEEE Computer Social club Press. p. 426. ISBN978-0-470-04212-0. Archived from the original on Apr 25, 2012.
28. ^ McDonald, Marc; Musson, Robert; Smith, Ross (2007). The Practical Guide to Defect Prevention . Microsoft Press. p. 480. ISBN978-0-7356-2253-1.
29. ^ "Release Early on, Release Oft" Archived May fourteen, 2011, at the Wayback Machine, Eric S. Raymond, The Cathedral and the Boutique
30. ^ "Wide Open up Source" Archived September 29, 2007, at the Wayback Car, Elias Levy, SecurityFocus, April 17, 2000
31. ^ Maurice Wilkes Quotes
32. ^ "PolySpace Technologies history". christele.faure.pagesperso-orange.fr . Retrieved August i, 2019.
33. ^ Le Goues, Claire; Holtschulte, Neal; Smith, Edward Thousand.; Brun, Yuriy; Devanbu, Premkumar; Forrest, Stephanie; Weimer, Westley (2015). "The ManyBugs and IntroClass Benchmarks for Automated Repair of C Programs". IEEE Transactions on Software Technology. 41 (12): 1236–1256. doi:x.1109/TSE.2015.2454513. ISSN 0098-5589.
34. ^ Simply, René; Jalali, Darioush; Ernst, Michael D. (2014). "Defects4J: a database of existing faults to enable controlled testing studies for Java programs". Proceedings of the 2014 International Symposium on Software Testing and Analysis - ISSTA 2014. pp. 437–440. CiteSeerX10.i.i.646.3086. doi:10.1145/2610384.2628055. ISBN9781450326452. S2CID 12796895.
35. ^ Sobreira, Victor; Durieux, Thomas; Madeiral, Fernanda; Monperrus, Martin; de Almeida Maia, Marcelo (2018). "Dissection of a bug dataset: Anatomy of 395 patches from Defects4J". 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER). pp. 130–140. arXiv:1801.06393. doi:10.1109/SANER.2018.8330203. ISBN978-1-5386-4969-5. S2CID 4607810.
36. ^ Madeiral, Fernanda; Urli, Simon; Maia, Marcelo; Monperrus, Martin; Maia, Marcelo A. (2019). "BEARS: An Extensible Java Issues Benchmark for Automated Program Repair Studies". 2019 IEEE 26th International Briefing on Software Assay, Evolution and Reengineering (SANER). pp. 468–478. arXiv:1901.06024. doi:10.1109/SANER.2019.8667991. ISBN978-ane-7281-0591-8. S2CID 58028949.
37. ^ Allen, Mitch (May–June 2002). "Bug Tracking Basics: A beginner's guide to reporting and tracking defects". Software Testing & Quality Technology Mag. Vol. 4, no. 3. pp. 20–24. Retrieved December xix, 2017.
38. ^ Rex Black (2002). Managing The Testing Process (2d Ed.). Wiley Republic of india Pvt. Limited. p. 139. ISBN9788126503131 . Retrieved June 19, 2021.
39. ^ Chris Vander Mey (August 24, 2012). Shipping Greatness - Practical Lessons on Edifice and Launching Outstanding Software, Learned on the Job at Google and Amazon. O'Reilly Media. pp. 79–81. ISBN9781449336608.
40. ^ Soleimani Neysiani, Behzad; Babamir, Seyed Morteza; Aritsugi, Masayoshi (October 1, 2020). "Efficient feature extraction model for validation functioning comeback of duplicate problems written report detection in software bug triage systems". Information and Software Technology. 126: 106344. doi:10.1016/j.infsof.2020.106344. S2CID 219733047.
41. ^ "5.3. Anatomy of a Bug". bugzilla.org. Archived from the original on May 23, 2013.
42. ^ "The Next Generation 1996 Lexicon A to Z: Slipstream Release". Adjacent Generation. No. fifteen. Imagine Media. March 1996. p. 41.
43. ^ Carr, Nicholas (2018). "'It's Not a Bug, Information technology'due south a Feature.' Trite—or Just Correct?". wired.com.
44. ^ Monperrus, Martin; Bruch, Marcel; Mezini, Mira (2010). "Detecting Missing Method Calls in Object-Oriented Software". ECOOP 2010 – Object-Oriented Programming (PDF). Lecture Notes in Computer Science. Vol. 6183. pp. two–25. doi:10.1007/978-three-642-14107-2_2. ISBN978-3-642-14106-five. S2CID 16724498.
45. ^ Kimbler, Grand. (1998). Feature Interactions in Telecommunication and Software Systems V. IOS Press. p. eight. ISBN978-90-5199-431-five.
46. ^ Syed, Mahbubur Rahman (July 1, 2001). Multimedia Networking: Technology, Management and Applications: Technology, Management and Applications. Idea Grouping Inc (IGI). p. 398. ISBN978-ane-59140-005-9.
47. ^ Wu, Chwan-Hwa (John); Irwin, J. David (Apr 19, 2016). Introduction to Computer Networks and Cybersecurity. CRC Press. p. 500. ISBN978-1-4665-7214-0.
48. ^ RFC 1263: "TCP Extensions Considered Harmful" quote: "the time to distribute the new version of the protocol to all hosts tin exist quite long (forever in fact). ... If there is the slightest incompatibly between onetime and new versions, anarchy tin effect."
49. ^ Yu, Zhongxing; Bai, Chenggang; Seinturier, Lionel; Monperrus, Martin (2019). "Characterizing the Usage, Development and Impact of Java Annotations in Do". IEEE Transactions on Software Technology. 47 (5): 1. arXiv:1805.01965. doi:x.1109/TSE.2019.2910516. S2CID 102351817.
50. ^ Dvorak, Daniel L. 1 NASA Study on Flying Software Complexity. CiteSeerXten.1.1.711.2976.
51. ^ Lientz, B. P.; Swanson, E. B.; Tompkins, G. Eastward. (1978). "Characteristics of Application Software Maintenance". Communications of the ACM. 21 (6): 466–471. doi:x.1145/359511.359522. S2CID 14950091.
52. ^ Amit, Idan; Feitelson, Dror G. (2020). "The Corrective Commit Probability Code Quality Metric". arXiv:2007.10912 [cs.SE].
53. ^ Ullman, Ellen (2004). The Bug. Picador. ISBN978-1-250-00249-5.

External links [edit]

• "Common Weakness Enumeration" – an expert webpage focus on bugs, at NIST.gov
• Issues type of Jim Grey – some other Bug blazon
• Picture of the "beginning computer bug" at the Wayback Car (archived January 12, 2015)
• "The Start Computer Issues!" – an email from 1981 most Adm. Hopper's bug
• "Toward Agreement Compiler Bugs in GCC and LLVM". A 2016 study of bugs in compilers

dicklifecyll.blogspot.com

Source: https://en.wikipedia.org/wiki/Software_bug

Share this post