Steven Woods

Applying plan recognition algorithms to program understanding

Program understanding is often viewed as the task of extracting plans and design goals from program source. As such, it is natural to try to apply standard AI plan recognition techniques to the program understanding problem. Yet program understanding researchers have quietly, but consistently, avoided the use of these plan recognition algorithms. This paper shows that treating program understanding as plan recognition is too simplistic and that traditional AI search algorithms for plan recognition are not suitable, as is, for program understanding. In particular, we show (1) that the program understanding task differs significantly from the typical general plan recognition task along several key dimensions, (2) that the program understanding task has particular properties that make it particularly amenable to constraint satisfaction techniques, and (3) that augmenting AI plan recognition algorithms with these techniques can lead to effective solutions for the program understanding problem.

The program understanding problem: analysis and a heuristic approach

Program understanding is the process of making sense of a complex source code. This process has been considered as computationally difficult and conceptually complex. So far no formal complexity results have been presented, and conceptual models differ from one researcher to the next. We formally prove that program understanding is NP hard. Furthermore, we show that even a much simpler subproblem remains NP hard. However we do not despair by this result, but rather offer an attractive problem solving model for the program understanding problem. Our model is built on a framework for solving constraint satisfaction problems, or CSPs, which are known to have interesting heuristic solutions. Specifically, we can represent and heuristically address previous and new heuristic approaches to the program understanding problem with both existing and specially designed constraint propagation and search algorithms.

ON THE IMPLEMENTATION AND EVALUATION OF AbTweak

In this paper, we describe the implementation and evaluation of the AbTweak planning system, a test bed for studying and teaching concepts in partial‐order planning, abstraction, and search control. We start by extending the hierarchical, precondition‐elimination abstraction of ABSTRIPS to partial‐order‐based, least‐commitment planners such as Tweak. The resulting system, AbTweak, illustrates the advantages of using abstraction to improve the efficiency of search. We show that by protecting a subset of abstract conditions achieved so far, and by imposing a bias on search toward deeper levels in a hierarchy, planning efficiency can be greatly improved. Finally, we relate AbTweak to other planning systems SNLP, ALPINE, and SIPE by exploring their similarities and differences.

Program Understanding as Constraint Satisfaction: Representation and Reasoning Techniques

The process of understanding a source code in a high-level programming language involves complex computation. Given a piece of legacy code and a library of program plan templates, understanding the code corresponds to building mappings from parts of the source code to particular program plans. These mappings could be used to assist an expert in reverse engineering legacy code, to facilitate software reuse, or to assist in the translation of the source into another programming language. In this paper we present a model of program understanding using constraint satisfaction. Within this model we intelligently compose a partial global picture of the source program code by transforming knowledge about the problem domain and the program itself into sets of constraints. We then systematically study different search algorithms and empirically evaluate their performance. One advantage of the constraint satisfaction model is its generality; many previous attempts in program understanding could now be cast under the same spectrum of heuristics, and thus be readily compared. Another advantage is the improvement in search efficiency using various heuristic techniques in constraint satisfaction.

Some experiments toward understanding how program plan recognition algorithms scale

Over the past decade, researchers in program understanding have formulated many program understanding algorithms but have published few studies of their relative scalability. Consequently, it is difficult to understand the relative limitations of these algorithms and to determine whether the field of program understanding is making progress. The paper attempts to address this deficiency by formalizing the search strategies of several different program understanding algorithms as constraint satisfaction problems, and by presenting some preliminary empirical scalability results for these constraint-based implementations. These initial results suggest that, at least under certain conditions, constraint-based program understanding is close to being applicable to real-world programs.

Toward a constraint-satisfaction framework for evaluating program-understanding algorithms

Different program understanding algorithms often use different representational frameworks and take advantage of numerous heuristic tricks. This situation makes it is difficult to compare these approaches and their performance. This paper addresses this problem by proposing constraint satisfaction as a general framework for describing program understanding algorithms, demonstrating how to tranform a complex existing program understanding algorithm into an instance of a constraint satisfaction problem, and showing how facilitates better understanding of its performance.

Exploiting domain-specific knowledge to refine simulation specifications

Discusses our approach to the problem of refining high-level simulation specifications. Our domain is simulated combat training for tank platoon members. Our input is a high-level specification for a training scenario and our output is an executable specification for the behavior of a network-based combat simulator. Our approach combines a detailed model of the tank training domain with nonlinear planning and constraint satisfaction techniques. Our initial implementation is successful in large part because of our use of domain knowledge to limit the branching factor of the planner and the constraint satisfaction engine.

New experiments with a constraint-based approach to program plan matching

In earlier work, the authors presented some preliminary empirical scalability results for a constraint-based program plan matching algorithm. Those initial experiments had several important shortcomings: they worked with a collection of artificially generated programs, and they applied a particular; general-purpose constraint satisfaction approach. The paper reports the results of a collection of new experiments that begin to address these deficiencies. In particular they have begun experimenting with programs based on real-world C code, and they have begun exploring new constraint satisfaction algorithms that take advantage of the particular characteristics of the program understanding problem. While not definitive, these new experiments provide further support for their earlier results, and they have led to a new approach that provides significant improvements in the scalability of the plan matching algorithm.