Alex Quilici’s research while affiliated with University of Hawaiʻi at Mānoa and other places

In discourse processing, two major problems are understanding the underlying connections between sucee.

Novice unix users have many incorrect beliefsabout unix commands. An intelligent advisory system for unix should provide explanatory responses that correct thesemistaken beliefs. To do so, the system must be able to understand how the useris justifying these beliefs, and it must be ableto provide justifications for its own beliefs.These tasks not only require knowledgeabout specific unix-related plans butalso abstract knowledge about how beliefs can be justified.This paper shows how this knowledge can be representedand sketches how it can be used to form justificationsfor advisor beliefs and to understand justifications given for user beliefs.Knowledge about belief justification is captured byjustification patterns,domain-independent knowledge structuresthat are similar to the abstract knowledge structures usedto understand the point behind a story.These justification patterns allow the advisor to understand andformulate novel belief justifications, giving the advisorthe ability to recognize and respond to novel misconceptions.

There are many commercial tools that address various aspects of the Year 2000 problem. None of these tools, however, make any documented use of plan-based techniques for automated concept recovery. This implies a general perception that plan-based techniques is not useful for this problem. This paper argues that this perception is incorrect and these techniques are in fact mature enough to make a significant contribution. In particular, we show representative code fragments illustrating "Year 2000" problems, discuss the problems inherent in recognizing the higher level concepts these fragments implement using pattern-based and rule-based techniques, demonstrate that they can be represented in a programming plan framework, and present some initial experimental evidence that suggests that current algorithms can locate these plans in linear time. Finally, we discuss several ways to integrate plan-based techniques with existing Year 2000 tools. 1991 Computing Reviews Classification System...

The plan matching problem is to determine whether a program plan is present in a program. This problem has been shown to be NP-hard, which makes it an open question whether plan matching algorithms can be developed that scale sufficiently well to be useful in practice. This paper discusses experiments in the scalability of a series of constraint-based program plan matching algorithms we have developed. These empirical studies have led to significant improvements in the scalability of our plan matching algorithm, and they suggest that this algorithm can be successfully applied to large, real-world programs.

Self-adaptive software requires high dependability robustness, adaptability, and availability. The article describes an infrastructure supporting two simultaneous processes in self-adaptive software: system evolution, the consistent application of change over time, and system adaptation, the cycle of detecting changing circumstances and planning and deploying responsive modifications

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.

Program understanding tools are currently not interoperable, leading researchers to waste significant resources reinventing already existing tools. Even commercial environments that have been designed to support the construction of program understanding tools have serious flaws in this regard. This paper discusses CORUM (Common Object-based Re-engineering Unified Model), an architecture to support interoperability between program understanding tools, and it provides several examples of CORUM's use in the construction of new tools for concept recognition and program visualization

Users often work directly with a collection of legacy simulation programs. These users are responsible for producing the input files for these programs, executing them, and managing their results. This project is to design and construct a general-purpose environment to support this process. In particular, we explore how to base this environment on an explicit object-oriented domain model that describes the domain actions that are simulated by existing simulation programs and the domain objects that are provided as input to or generated as output from these programs. The goal is to demonstrate that it is both possible and beneficial to construct an environment through which users interact with legacy simulation programs solely through an explicit domain model. This report describes the general architecture of such an environment and provides detailed examples that show how this environment can be applied to support users working with a collection of programs that simulate the formation and orbit of space debris.

1 Introduction It is an open question whether automated program understanding can become a practical, useable tool in the reverse engineering or maintaining of existing, real-world legacy systems. However, there are clearly several traits that any deployable automated program understanding tool must possess: 1. It must be based on an understanding algorithm that scales in practice to large programs. 2. It must produce an understanding targeted to the specific reverse engineering or maintenance tasks it is being used to support. 3. It must provide mechanisms that allow the programmers who perform reverse engineering or maintenance tasks to update its knowledge base. 4. It must integrate with other, existing tools that support maintenance and reverse engineering. 5. Finally, it must help the end-user achieve tasks more simply and more cheaply than alternative approaches. This abstract provides an overview of our approach to constructing a program understanding tool that possesses t...

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