Functional programs that explain their work

Abstract

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.

A core calculus for provenance

“…In addition, we encountered a problem with proving correctness of the disclosure slicing algorithm proposed in [3]; specifically, Lemma 2 in the conference version had a subtle problem, which we avoid through a reformulation of the disclosure slicing algorithm. This article is also closely related to work on using traces for program slicing [40] published in ICFP 2012. The two papers present different aspects of a single research project; the trace model and some aspects of the slicing algorithms are closely related.…”

“…The tracing and extraction features are formalized later in the article, and our prototype supports these examples, as well as the disclosure and obfuscation slicing algorithms presented later in the paper. The Slicer and LambdaCalc tools of Perera et al [40,39] employ similar ideas, and have been run on larger examples, but focus on slicing as a debugging and program understanding technique and does not yet support provenance extraction or disclosure and obfuscation slicing. Developing a unified and mature implementation supporting all of these ideas is left for future work; Perera et al [40,39] should be consulted for further implementation details.…”

A Lightweight Hat

“…Languages Perera et al (2012) de ne another tracing model for lazy functional programs that is based on program slicing. They prove several desirable properties for their approach.…”

Toward a Theory of Self-explaining Computation

“…Our recent work [3,49] considers traces and trace slicing for a pure, call-byvalue calculus with product, sum and recursive types, and recursive functions, using a conventional large-step semantics; paths become unwieldy in this setting, and we adopt an alternative approach based on partial values. Other features such as exceptions, laziness, and first-class continuations (call/cc) pose similar, and possibly greater, challenges from the point of view of provenance.…”

“…We also describe the use of derivations for a form of incremental computation (loosely inspired by self-adjusting computation [5]), in order to demonstrate that derivations are expressive enough to meet this strong requirement. We have made additional contributions since the first version of this paper was written [3,49], and we conclude with a discussion of these results and future steps.…”