Algorithmic program debugging - Revision history

Valeria Borodich: /* growthexperiments-addlink-summary-summary:2|1|0 */

2025-01-22T08:51:25Z

Link suggestions feature: 2 links added.

← Previous revision		Revision as of 08:51, 22 January 2025
Line 9:		Line 9:
	==Origins, current and future directions==		==Origins, current and future directions==

	Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.		Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic [[programming language]]) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.
	The research and development in the field of algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>		The research and development in the field of algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>
	Three decades since its introduction, algorithmic debugging is still an active field of computer science research <ref>Caballero, Rafael, Riesco, Adrián, Silva, Josep. ''A survey of algorithmic debugging''. ACM Computing Surveys, Volume 50 Issue 4, 2017.</ref> and will probably remain so for decades as no panacea is in sight.		Three decades since its introduction, algorithmic debugging is still an active field of [[computer science]] research <ref>Caballero, Rafael, Riesco, Adrián, Silva, Josep. ''A survey of algorithmic debugging''. ACM Computing Surveys, Volume 50 Issue 4, 2017.</ref> and will probably remain so for decades as no panacea is in sight.

	==References==		==References==

Nyq: lc common adjective

2021-06-11T09:37:44Z

lc common adjective

← Previous revision		Revision as of 09:37, 11 June 2021
Line 10:		Line 10:

	Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.		Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.
	The research and development in the field of ~~Algorithmic~~ debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>		The research and development in the field of algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>
	Three decades since its introduction, algorithmic debugging is still an active field of computer science research <ref>Caballero, Rafael, Riesco, Adrián, Silva, Josep. ''A survey of algorithmic debugging''. ACM Computing Surveys, Volume 50 Issue 4, 2017.</ref> and will probably remain so for decades as no panacea is in sight.		Three decades since its introduction, algorithmic debugging is still an active field of computer science research <ref>Caballero, Rafael, Riesco, Adrián, Silva, Josep. ''A survey of algorithmic debugging''. ACM Computing Surveys, Volume 50 Issue 4, 2017.</ref> and will probably remain so for decades as no panacea is in sight.

Headbomb: clean up, replaced: ACM Computing Surveys (CSUR) → ACM Computing Surveys

2020-07-03T15:05:51Z

clean up, replaced: ACM Computing Surveys (CSUR) → ACM Computing Surveys

← Previous revision		Revision as of 15:05, 3 July 2020
Line 11:		Line 11:
	Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.		Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.
	The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>		The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>
	Three decades since its introduction, algorithmic debugging is still an active field of computer science research <ref>Caballero, Rafael, Riesco, Adrián, Silva, Josep. ''A survey of algorithmic debugging''. ACM Computing Surveys ~~(CSUR)~~, Volume 50 Issue 4, 2017.</ref> and will probably remain so for decades as no panacea is in sight.		Three decades since its introduction, algorithmic debugging is still an active field of computer science research <ref>Caballero, Rafael, Riesco, Adrián, Silva, Josep. ''A survey of algorithmic debugging''. ACM Computing Surveys, Volume 50 Issue 4, 2017.</ref> and will probably remain so for decades as no panacea is in sight.

	==References==		==References==
	{{Reflist}}		{{Reflist}}


	[[Category:Debugging]]		[[Category:Debugging]]

JJMC89: Removing link(s): Wikipedia:Miscellany for deletion/7 pseudo-portal forks of outline pages (Xunlink)

2019-05-02T02:02:53Z

Removing link(s): Wikipedia:Miscellany for deletion/7 pseudo-portal forks of outline pages (Xunlink)

← Previous revision		Revision as of 02:02, 2 May 2019
Line 14:		Line 14:

	==References==		==References==
	{{portal\|Computing}}
	{{Reflist}}		{{Reflist}}

Sameson: Added new reference "A survey on algorithmic debugging"

2017-11-04T17:36:26Z

Added new reference "A survey on algorithmic debugging"

← Previous revision		Revision as of 17:36, 4 November 2017
Line 11:		Line 11:
	Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.		Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.
	The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>		The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>
	Three decades since its introduction, algorithmic debugging is still an active field of computer science research and will probably remain so for decades as no panacea is in sight.		Three decades since its introduction, algorithmic debugging is still an active field of computer science research <ref>Caballero, Rafael, Riesco, Adrián, Silva, Josep. ''A survey of algorithmic debugging''. ACM Computing Surveys (CSUR), Volume 50 Issue 4, 2017.</ref> and will probably remain so for decades as no panacea is in sight.

	==References==		==References==

Cljeffery: removed repeat/duplicate W.F. Clocksin in author list, he is already the first author of [4]

2017-06-30T17:16:07Z

removed repeat/duplicate W.F. Clocksin in author list, he is already the first author of [4]

← Previous revision		Revision as of 17:16, 30 June 2017
Line 9:		Line 9:
	==Origins, current and future directions==		==Origins, current and future directions==

	Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., Christopher S. Mellish~~, and W. F. Clocksin~~. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.		Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., and Christopher S. Mellish. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.
	The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>		The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>
	Three decades since its introduction, algorithmic debugging is still an active field of computer science research and will probably remain so for decades as no panacea is in sight.		Three decades since its introduction, algorithmic debugging is still an active field of computer science research and will probably remain so for decades as no panacea is in sight.

Magic links bot: Replace magic links with templates per local RfC and MediaWiki RfC

2017-05-25T10:47:09Z

Replace magic links with templates per local RfC and MediaWiki RfC

← Previous revision		Revision as of 10:47, 25 May 2017
Line 9:		Line 9:
	==Origins, current and future directions==		==Origins, current and future directions==

	Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. ISBN 0-262-19218-7</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., Christopher S. Mellish, and W. F. Clocksin. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.		Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. {{ISBN\|0-262-19218-7}}</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., Christopher S. Mellish, and W. F. Clocksin. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.
	The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>		The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>
	Three decades since its introduction, algorithmic debugging is still an active field of computer science research and will probably remain so for decades as no panacea is in sight.		Three decades since its introduction, algorithmic debugging is still an active field of computer science research and will probably remain so for decades as no panacea is in sight.

OldManNIck: /* Overview */

2016-05-16T07:16:40Z

Overview

← Previous revision		Revision as of 07:16, 16 May 2016
Line 3:		Line 3:
	==Overview==		==Overview==

	[[Debugging\|Program debugging]] is an ~~unavoidable~~ part of software development. Until the 1980s the craft of program debugging, practiced by every programmer, was without any theoretical foundation.<ref>Silva, Josep. "A survey on algorithmic debugging strategies." ''Advances in Engineering Software'' 42.11 (2011): 976-991/</ref> In the early 1980s, systematic and principled approaches to program debugging were developed. In general, a bug occurs when a programmer has a specific intention regarding what the program should do, yet the program actually written exhibits a different behavior than intended in a particular case.		[[Debugging\|Program debugging]] is an extremely common part of software development. Until the 1980s the craft of program debugging, practiced by every programmer, was without any theoretical foundation.<ref>Silva, Josep. "A survey on algorithmic debugging strategies." ''Advances in Engineering Software'' 42.11 (2011): 976-991/</ref> In the early 1980s, systematic and principled approaches to program debugging were developed. In general, a bug occurs when a programmer has a specific intention regarding what the program should do, yet the program actually written exhibits a different behavior than intended in a particular case.
	One way of organizing the debugging process is to automate it (at least partially) via an algorithmic debugging technique.<ref>Zeller, Andreas. ''Why programs fail: a guide to systematic debugging''. Elsevier, 2009./</ref> The idea of algorithmic debugging is to have a tool that guides the programmer along the debugging process interactively: It does so by asking the programmer about possible bug sources.		One way of organizing the debugging process is to automate it (at least partially) via an algorithmic debugging technique.<ref>Zeller, Andreas. ''Why programs fail: a guide to systematic debugging''. Elsevier, 2009./</ref> The idea of algorithmic debugging is to have a tool that guides the programmer along the debugging process interactively: It does so by asking the programmer about possible bug sources.
	The algorithmic debugging technique constructs an internal representation of all computations and sub-computations performed during the execution of a buggy program (an execution tree). Then, it asks the programmer about the correctness of such computations. The programmer answers "YES" when the result is correct or "NO" when the result is wrong. Some algorithmic debuggers also accept the answer "I don't know" when the programmer cannot give an answer (e.g., because the question is too complex). Thus, the answers of the programmer guide the search for the bug until it is isolated by discarding correct parts of the program. The algorithmic debugging process finds one bug at a time. In order to find different bugs, the process should be restarted again for each different bug.		The algorithmic debugging technique constructs an internal representation of all computations and sub-computations performed during the execution of a buggy program (an execution tree). Then, it asks the programmer about the correctness of such computations. The programmer answers "YES" when the result is correct or "NO" when the result is wrong. Some algorithmic debuggers also accept the answer "I don't know" when the programmer cannot give an answer (e.g., because the question is too complex). Thus, the answers of the programmer guide the search for the bug until it is isolated by discarding correct parts of the program. The algorithmic debugging process finds one bug at a time. In order to find different bugs, the process should be restarted again for each different bug.

Dgpop: /* References */ category

2016-02-25T19:24:17Z

References: category

← Previous revision		Revision as of 19:24, 25 February 2016
Line 17:		Line 17:
	{{Reflist}}		{{Reflist}}


	[[Category:Logic programming languages\|logic programming languages]]
	[[Category:Debugging]]		[[Category:Debugging]]

Yobot: /* Origins, current and future directions */WP:CHECKWIKI error fixes (ISBN style fixes), replaced: ISBN 0-262-19218-7 → ISBN 0-262-19218-7 using AWB (10809)

2015-01-28T09:27:10Z

Origins, current and future directions: WP:CHECKWIKI error fixes (ISBN style fixes), replaced: ISBN 0-262-19218-7 → ISBN 0-262-19218-7 using AWB (10809)

← Previous revision		Revision as of 09:27, 28 January 2015
Line 9:		Line 9:
	==Origins, current and future directions==		==Origins, current and future directions==

	Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. [[ISBN]] ~~[[Special:BookSources/~~0-262-19218-7~~\|0-262-19218-7]]~~</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., Christopher S. Mellish, and W. F. Clocksin. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.		Algorithmic debugging was first developed by [[Ehud Shapiro]] during his PhD research at Yale University, as introduced in his PhD thesis,<ref>Shapiro, Ehud Y. (1983). ''Algorithmic program debugging''. Cambridge, Mass: MIT Press. ISBN 0-262-19218-7</ref> selected as a 1982 ACM Distinguished Dissertation. Shapiro implemented the method of algorithmic debugging in Prolog<ref>Clocksin, William F., Christopher S. Mellish, and W. F. Clocksin. ''Programming in PROLOG''. Vol. 4. Berlin etc.: Springer, 1987.</ref> (a general purpose logic programming language) for the debugging of [[Logic programming\|logic programs]]. In case of [[Logic programming\|logic programs]], the intended behavior of the program is a model (a set of simple true statements) and bugs are manifested as program [[Completeness (logic)\|incompleteness]] (inability to prove a true statement) or [[Correctness (computer science)\|incorrectness]] (ability to prove a false statement). The algorithm would identify a false statement in the program and provide a counter-example to it or a missing true statement that it or its generalization should be added to the program. A method to handle [[non-termination]] was also developed.
	The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>		The research and development in the field of Algorithmic debugging has made major improvements over the original algorithms for debugging Prolog and other and extended the ideas to other language paradigms such as [[functional languages]] and [[Object-oriented programming\|object oriented languages]].<ref>Naish, Lee. ''A declarative debugging scheme''. Department of Computer Science, University of Melbourne, 1995.</ref>
	Three decades since its introduction, algorithmic debugging is still an active field of computer science research and will probably remain so for decades as no panacea is in sight.		Three decades since its introduction, algorithmic debugging is still an active field of computer science research and will probably remain so for decades as no panacea is in sight.