Declarative Debugging of Rewriting Logic Specifications

Riesco, Adrián; Verdejo, Alberto; Caballero, Rafael; Martí-Oliet, Narciso

doi:10.1007/978-3-642-03429-9_20

Cited by 13 publications

(10 citation statements)

References 24 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…For instance, a function that returns a value of type T may return a value of type (T, DebugTree) after the transformation, being DebugTree a suitable datatype defined to represent the debugging tree. (2) Using code instrumentation [Nilsson and Fritzson 1992;Nilsson 1998;Faddegon and Chitil 2015], reflection [Shapiro 1982a;Lloyd 1987b;Binks 1995;Tessier and Ferrand 2000;MacLarty 2005;Riesco et al 2012;, or directly modifying the compiler [Nilsson 2001] in order to produce the debugging tree.…”

Section: Implementation Techniquesmentioning

confidence: 99%

“…In almost all cases, the debugging tree is obtained by using a meta-interpreter, taking advantage of the reflection possibilities of logic languages such as Prolog, and all the works include results of soundness and completeness. A very similar approach was later applied to the more general CLP scheme [Fromherz 1993;Tessier and Ferrand 2000], to the combination with assertions [Wlodzimierz et al 1988], and to multi-paradigm languages such as Gödel or Maude [Binks 1995;Riesco et al 2012].…”

Section: Logic Programmingmentioning

confidence: 99%

See 1 more Smart Citation

A Survey of Algorithmic Debugging

2017

Self Cite

View full text Add to dashboard Cite

Algorithmic debugging is a technique proposed in 1982 by E.Y. Shapiro in the context of logic programming. This survey shows how the initial ideas have been developed to become a widespread debugging schema fitting many different programming paradigms, and with applications out of the program debugging field. We describe the general framework and the main issues related to the implementations in different programming paradigms, and discuss several proposed improvements and optimizations. We also review the main algorithmic debugger tools that have been implemented so far and compare their features. From this comparison, we elaborate a summary of desirable characteristics that should be considered when implementing future algorithmic debuggers. Categories and Subject Descriptors: F.3.1 [Theory of Computation]: Logics and meaning of programsspecifying and verifying and reasoning about programs; D.3.1 [Software]: Programming Languages-formal definitions and theory

show abstract

Section: Implementation Techniquesmentioning

confidence: 99%

Section: Logic Programmingmentioning

confidence: 99%

A Survey of Algorithmic Debugging

2017

Self Cite

View full text Add to dashboard Cite

show abstract

“…It includes several program analyzers and theorem provers, which are all accessible in [29]. Other available tools in [29] are not yet integrated, such as the declarative debugger of Maude [30] and Maude's model checkers [4,7]. The declarative debugger is based on Shapiro's algorithmic debugging technique [31] and supports the debugging of wrong results (erroneous reductions, sort inferences, and rewrites) and incomplete results (not completely reduced normal forms, greater than expected least sorts, and incomplete sets of reachable terms) in object-oriented, parameterized modules written in (Full) Maude.…”

Section: Related Workmentioning

confidence: 99%

Debugging Maude programs via runtime assertion checking and trace slicing

Alpuente¹,

Ballis²,

Frechina³

et al. 2016

Journal of Logical and Algebraic Methods in Programming

View full text Add to dashboard Cite

In this paper we propose a dynamic analysis methodology for improving the diagnosis of erroneous Maude programs. The key idea is to combine runtime checking and dynamic trace slicing for automatically catching errors at runtime while reducing the size and complexity of the erroneous traces to be analyzed (i.e., those leading to states failing to satisfy some of the assertions). First, we formalize a technique that is aimed at automatically detecting deviations of the program behavior (symptoms) with respect to two types of user-defined assertions: functional assertions and system assertions. The proposed dynamic checking is provably sound in the sense that all errors flagged are definitely violations of the specifications. Then, upon eventual assertion violations we generate accurate trace slices that help identify the cause of the error. Our methodology is based on (i) a logical notation for specifying assertions that are imposed on execution runs; (ii) a runtime checking technique that dynamically tests the assertions; and (iii) a mechanism based on (equational) least general generalization that automatically derives accurate criteria for slicing from falsified assertions. Finally, we report on an implementation of the proposed technique in the assertion-based, dynamic analyzer ABETS and show how the forward and backward tracking of asserted program properties leads to a thorough trace analysis algorithm that can be used for program diagnosis and debugging

show abstract

“…To avoid this problem we place transitivity nodes in such a way that (i) the debugging tree becomes as balanced as possible, which improves the behavior of the navigation strategies and (ii) the questions in the debugging tree refer to final results, making the questions easier to answer. The tree transformation for this semantics, similar to the one in [14], takes advantage of transitivity rules while keeping the correctness and completeness of the technique. Thus, in this case the APT ss function is defined as:…”

Section: Declarative Debugging With Small-step Semanticsmentioning

confidence: 99%

“…Our declarative debugger for Maude specifications is presented in [14]. This debugger uses the standard calculus for rewriting logic 1 to build the debugging trees, which are used to locate bugs in equations, membership axioms, and rules.…”

Section: Introductionmentioning

confidence: 99%

Using Big-Step and Small-Step Semantics in Maude to Perform Declarative Debugging

Riesco

2014

Functional and Logic Programming

View full text Add to dashboard Cite

Declarative debugging is a semi-automatic debugging technique that abstracts the execution details to focus on results. This technique builds a debugging tree representing an incorrect computation and traverses it by asking questions to the user until the error is found. In previous works we have presented a declarative debugger for Maude specifications. Besides a programming language, Maude is a semantic framework where several other languages can be specified. However, our declarative debugger is only able to find errors in Maude specifications, so it cannot find bugs on the programs written on the languages being specified. We study in this paper how to modify our declarative debugger to find this kind of errors when defining programming languages using big-step and small-step semantics, two generic approaches that allow to specify a wide range of languages in a natural way. We obtain our debugging trees by modifying the proof trees obtained from the semantic rules. We have extended our declarative debugger to deal with this kind of debugging, and we illustrate it with an example.

show abstract

Declarative Debugging of Rewriting Logic Specifications

Cited by 13 publications

References 24 publications

A Survey of Algorithmic Debugging

A Survey of Algorithmic Debugging

Debugging Maude programs via runtime assertion checking and trace slicing

Using Big-Step and Small-Step Semantics in Maude to Perform Declarative Debugging

Contact Info

Product

Resources

About