• Documents
  • Authors
  • Tables
  • Log in
  • Sign up
  • MetaCart
  • DMCA
  • Donate

CiteSeerX logo

Advanced Search Include Citations
Advanced Search Include Citations | Disambiguate

Dynamic Slicing in Higher-Order Programming Languages (1997)

by S Biswas
Add To MetaCart

Tools

Sorted by:
Results 1 - 9 of 9

A Core Calculus of Dependency

by Martín Abadi , Anindya Banerjee, Nevin Heintze, Jon G. Riecke - IN PROC. 26TH ACM SYMP. ON PRINCIPLES OF PROGRAMMING LANGUAGES (POPL , 1999
"... Notions of program dependency arise in many settings: security, partial evaluation, program slicing, and call-tracking. We argue that there is a central notion of dependency common to these settings that can be captured within a single calculus, the Dependency Core Calculus (DCC), a small extension ..."
Abstract - Cited by 248 (21 self) - Add to MetaCart
Notions of program dependency arise in many settings: security, partial evaluation, program slicing, and call-tracking. We argue that there is a central notion of dependency common to these settings that can be captured within a single calculus, the Dependency Core Calculus (DCC), a small extension of Moggi's computational lambda calculus. To establish this thesis, we translate typed calculi for secure information flow, binding-time analysis, slicing, and call-tracking into DCC. The translations help clarify aspects of the source calculi. We also define a semantic model for DCC and use it to give simple proofs of noninterference results for each case.

Provenance as dependency analysis

by James Cheney, Amal Ahmed, Umut A. Acar - Proceedings of the 11th International Symposium on Database Programming Languages (DBPL 2007), number 4797 in LNCS , 2007
"... Abstract. Provenance is information recording the source, derivation, or history of some information. Provenance tracking has been studied in a variety of settings; however, although many design points have been explored, the mathematical or semantic foundations of data provenance have received comp ..."
Abstract - Cited by 42 (16 self) - Add to MetaCart
Abstract. Provenance is information recording the source, derivation, or history of some information. Provenance tracking has been studied in a variety of settings; however, although many design points have been explored, the mathematical or semantic foundations of data provenance have received comparatively little attention. In this paper, we argue that dependency analysis techniques familiar from program analysis and program slicing provide a formal foundation for forms of provenance that are intended to show how (part of) the output of a query depends on (parts of) its input. We introduce a semantic characterization of such dependency provenance, show that this form of provenance is not computable, and provide dynamic and static approximation techniques. 1
(Show Context)

Citation Context

...wn when negation, grouping, or aggregation are considered. These intuitions have also motivated rigorous approaches to seemingly quite different problems, such as aiding debugging via program slicing =-=[7, 15, 23]-=-, supporting efficient memoization and caching [2, 4], and improving program security using information flow analysis [19]. As Abadi et al. have argued [1], slicing, information flow, and several othe...

Functional Programs that Explain their Work

by Roly Perera, Umut A. Acar, James Cheney, Paul Blain Levy
"... We present techniques that enable higher-order functional computations to “explain ” their work by answering questions about how parts of their output were calculated. As explanations, we consider the traditional notion of program slices, which we show can be inadequate, and propose a new notion: tr ..."
Abstract - Cited by 5 (3 self) - Add to MetaCart
We present techniques that enable higher-order functional computations to “explain ” their work by answering questions about how parts of their output were calculated. As explanations, we consider the traditional notion of program slices, which we show can be inadequate, and propose a new notion: trace slices. We present techniques for specifying flexible and rich slicing criteria based on partial expressions, parts of which have been replaced by holes. We characterise program slices in an algorithm-independent fashion and show that a least slice for a given criterion exists. We then present an algorithm, called unevaluation, for computing least program slices from computations reified as traces. Observing a limitation of program slices, we develop a notion of trace slice as another form of explanation and present an algorithm for computing them. The unevaluation algorithm can be applied to any subtrace of a trace slice to compute a program slice whose evaluation generates that subtrace. This close correspondence between programs, traces, and their slices can enable the programmer to understand a computation interactively, in terms of the programming language in which the computation is expressed. We present an implementation in the form of a tool, discuss some important practical implementation concerns and present some techniques for addressing them.
(Show Context)

Citation Context

... functional programs. Their techniques compute static slices, however, and apply only to first-order functional programs; they also do not preserve the semantics of strict functional programs. Biswas =-=[6]-=- considers strict, higher-order functional programs and proposes slicing techniques with a single form of criterion: the entire output of the program. Ochoa, Silva, and Vidal [19] present techniques t...

Lightweight Program Specialization via Dynamic Slicing

by Claudio Ochoa, et al. , 2005
"... Program slicing is a well-known technique that extracts from a program those statements which are relevant to a particular criterion. While static slicing does not consider any input data, dynamic slices are computed from a particular program execution. Thus, dynamic slicers are usually easier to de ..."
Abstract - Cited by 2 (0 self) - Add to MetaCart
Program slicing is a well-known technique that extracts from a program those statements which are relevant to a particular criterion. While static slicing does not consider any input data, dynamic slices are computed from a particular program execution. Thus, dynamic slicers are usually easier to design and implement. In this work, we present a program specialization technique for lazy functional logic programming which is based on dynamic slicing. Our method exploits the code size reduction capabilities of slicing in order to produce a version of the original program specialized w.r.t. a given criterion. We also introduce some simple, post-processing transformations that allow us to further simplify the specialized program. The kind of specialization performed by our approach cannot be achieved with other related techniques like partial evaluation.

L.S.: Higher-Order Lazy Functional Slicing

by Nuno F. Rodrigues, Luís S. Barbosa
"... Abstract: Program slicing is a well known family of techniques intended to identify and isolate code fragments which depend on, or are depended upon, specific program entities. This is particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. M ..."
Abstract - Cited by 1 (1 self) - Add to MetaCart
Abstract: Program slicing is a well known family of techniques intended to identify and isolate code fragments which depend on, or are depended upon, specific program entities. This is particularly useful in the areas of reverse engineering, program understanding, testing and software maintenance. Most slicing methods, and corresponding tools, target either the imperative or the object oriented paradigms, where program slices are computed with respect to a variable or a program statement. Taking a complementary point of view, this paper focuses on the slicing of higher-order functional programs under a lazy evaluation strategy. A prototype of a Haskell slicer, built as proof-of-concept for these ideas, is also introduced.
(Show Context)

Citation Context

...t a specific (sub)expression in the code, represents a more natural way for the analyst to encode the relevant aspects of the code that he/she wants isolated. Perhaps the work most related to ours is =-=[2]-=-, where the author presents an algorithm for dynamic slicing of strict higher-order functional languages followed by a brief adaptation of the algorithm to lazy evaluation. A major difference with the...

Dynamic Slicing of Lazy Functional Programs Based on Redex Trails

by Claudio Ochoa, Josep Silva, Germán Vidal , 2007
"... Tracing computations is a widely used methodology for program debugging. Lazy languages, however, pose new demands on tracing techniques because following the actual trace of a computation is generally useless. Typically, tracers for lazy languages rely on the construction of a redex trail, a graph ..."
Abstract - Cited by 1 (0 self) - Add to MetaCart
Tracing computations is a widely used methodology for program debugging. Lazy languages, however, pose new demands on tracing techniques because following the actual trace of a computation is generally useless. Typically, tracers for lazy languages rely on the construction of a redex trail, a graph that stores the reductions performed in a computation. While tracing provides a significant help for locating bugs, the task still remains complex. A well-known debugging technique for imperative programs is based on dynamic slicing, a method for finding the program statements that influence the computation of a value for a specific program input. In this work, we introduce a novel technique for dynamic slicing in first-order lazy functional languages. Rather than starting from scratch, our technique relies on (a slight extension of) redex trails. We provide a notion of dynamic slice and introduce a method to compute it from the redex trail of a computation. We also sketch the extension of our technique to deal with a functional logic language. A clear advantage of our proposal is that one can enhance existing tracers with slicing capabilities with a modest implementation effort, since the same data structure (the redex trail) can be used for both tracing and slicing.

Under consideration for publication in Theory and Practice of Logic Programming 1 Forward Slicing of Functional Logic Programs by Partial Evaluation∗

by Josep Silva, Germán Vidal , 2005
"... Program slicing has been mainly studied in the context of imperative languages, where it has been applied to a wide variety of software engineering tasks, like program understanding, maintenance, debugging, testing, code reuse, etc. This work introduces the first forward slicing technique for declar ..."
Abstract - Add to MetaCart
Program slicing has been mainly studied in the context of imperative languages, where it has been applied to a wide variety of software engineering tasks, like program understanding, maintenance, debugging, testing, code reuse, etc. This work introduces the first forward slicing technique for declarative multi-paradigm programs which integrate features from functional and logic programming. Basically, given a program and a slicing criterion (a function call in our setting), the computed forward slice contains those parts of the original program which are reachable from the slicing criterion. Our approach to program slicing is based on an extension of (online) partial evaluation. Therefore, it provides a simple way to develop program slicing tools from existing partial evaluators and helps to clarify the relation between both methodologies. A slicing tool for the multi-paradigm language Curry, which demonstrates the usefulness of our approach, has been implemented in Curry itself.
(Show Context)

Citation Context

... 11 ness—in the sense of Huet and Lévy (1992)—and slicing is not new; indeed, there exist several approaches to slicing of functional programs which rely on the computation of neededness information (=-=Biswas 1997-=-; Field and Tip 1998). Clearly, t must compute the same value in R and in the computed slice. In particular, the original program is always a correct slice w.r.t. any slicing criterion. Our aim is thu...

A Core Calculus of Dependency

by Martín Abadi, Anindya Banerjee , Nevin Heintze, Jon G. Riecke
"... ...partial evaluation, program slicing, and call-tracking. We argue that there is a central notion of dependency common to these settings that can be captured within a single calculus, the Dependency Core Calculus (DCC), a small extension of Moggi’s computational lambda calculus. To establish this t ..."
Abstract - Add to MetaCart
...partial evaluation, program slicing, and call-tracking. We argue that there is a central notion of dependency common to these settings that can be captured within a single calculus, the Dependency Core Calculus (DCC), a small extension of Moggi’s computational lambda calculus. To establish this thesis, we translate typed calculi for secure information flow, binding-time analysis, slicing, and call-tracking into DCC. The translations help clarify aspects of the source calculi. We also define a semantic model for DCC and use it to give simple proofs of noninterference results for each case.
(Show Context)

Citation Context

...ubterms, we follow Abadi et al. [2] and use a labelled lambda calculus. We give a conservative approximation of the labelled operational semantics using a type system, whereas previous work by Biswas =-=[3]-=- employs set-based analysis. The type system for slicing is similar to that of the SLam calculus. A type s is a pair consisting of a structural part, t, and a set of labels, κ, denoting slicing inform...

ABSTRACT Dynamic Slicing Based on Redex Trails ∗

by Claudio Ochoa, Dsic T. U. Valencia, Josep Silva, Germán Vidal
"... Tracing computations is a widely used methodology for program debugging. Lazy languages, in particular, pose new demands on tracing techniques since following the actual trace of a computation is generally useless. Typically, they rely on the construction of a redex trail, a graph that describes the ..."
Abstract - Add to MetaCart
Tracing computations is a widely used methodology for program debugging. Lazy languages, in particular, pose new demands on tracing techniques since following the actual trace of a computation is generally useless. Typically, they rely on the construction of a redex trail, a graph that describes the reductions of a computation and its relationships. While tracing provides a significant help for locating bugs, the task still remains complex. A well-known debugging technique for imperative programs is based on dynamic slicing, a method to find the program statements that influence the computation of a value for a specific program input. In this work, we introduce a novel technique for dynamic slicing in lazy functional logic languages. Rather than starting from scratch, our technique relies on (a slight extension of) redex trails. We provide a method to compute a correct and minimal dynamic slice from the redex trail of a computation. A clear advantage of our proposal is that one can enhance existing tracers with slicing capabilities with a modest implementation effort, since the same data structure (the redex trail) can be used for both tracing and slicing.
(Show Context)

Citation Context

...ote that variables in a let construct or patterns in a case expression cannot be addressed (since they will not be considered in the slicing process). While other approaches to dynamic slicing (e.g., =-=[3]-=-) consider some form of explicit labeling for each program expression, our program positions can be seen as a form of implicit labeling. In the construction of the extended trail, we adopt the followi...

Powered by: Apache Solr
  • About CiteSeerX
  • Submit and Index Documents
  • Privacy Policy
  • Help
  • Data
  • Source
  • Contact Us

Developed at and hosted by The College of Information Sciences and Technology

© 2007-2019 The Pennsylvania State University