Kurt Stirewalt

Model-driven reverse engineering

Reverse engineering is the process of comprehending software and producing a model of it at a high abstraction level, suitable for documentation, maintenance, or reengineering. But from a managers viewpoint, there are two painful problems: 1) Its difficult or impossible to predict how much time reverse engineering will require. 2) There are no standards to evaluate the quality of the reverse engineering that the maintenance staff performs. Model-driven reverse engineering can overcome these difficulties. A model is a high-level representation of some aspect of a software system. MDRE uses the features of modeling technology but applies them differently to address the maintenance managers problems. Our approach to MDRE uses formal specification and automatic code generation to reverse the reverse-engineering process. Models written in a formal specification language called SLANG describe both the application domain and the program being reverse engineered, and interpretations annotate the connections between the two. The ability to generate a similar version of a program gives managers a fixed target for reverse engineering. This, in turn, enables better effort prediction and quality evaluation, reducing development risk.

Understanding interleaved code

Complex programs often contain multiple, interwoven strands of computation, each responsible for accomplishing a distinct goal. The individual strands responsible for each goal are typically delocalized and overlap rather than being composed in a simple linear sequence. We refer to these code fragments as being interleaved. Interleaving may be intentional-for example, in optimizing a program, a programmer might use some intermediate result for several purposes-or it may creep into a program unintentionally, due to patches, quick fixes, or other hasty maintenance practices. To understand this phenomenon, we have looked at a variety of instances of interleaving in actual programs and have distilled characteristic features. This paper presents our characterization of interleaving and the implications it has for tools that detect certain classes of interleaving and extract the individual strands of computation. Our exploration of interleaving has been done in the context of a case study of a corpus of production mathematical software, written in Fortran from the Jet Propulsion Laboratory. This paper also describes our experiences in developing tools to detect specific classes of interleaving in this software, driven by the need to enhance a formal description of this software librarys components. The description, in turn aids in the automated component-based synthesis of software using the library.

Incremental dependence analysis for interactive parallelization

Incrementally updating dependence information during interactive parallelization is a difficult proposition. We have developed a tool (PAT) that maintains dependence information during incremental transformations to a Fortran program, including loop parallelization, code <italic>replication, alignment</italic> and <italic>shifting</italic>, as well as <italic>insertion</italic> and <italic>deletion</italic> of code including parallel primitives. Our analysis is based on a variation on the standard approach to dependence graph generation, with program wide and local information separated in a <italic>sequential</italic> and a <italic>parallel</italic> dependence graph.

Mapping ORM to datalog: an overview

Optimization of modern businesses is becoming increasingly dependent on business intelligence and rule-based software to perform predictive analytics over massive data sets and enforce complex business rules. This has led to a resurgence of interest in datalog, because of its powerful capability for processing complex rules, especially those involving recursion, and the exploitation of novel data structures that provide performance advantages over relational database systems. ORM 2 is a conceptual approach for fact oriented modeling that provides a high level graphical and textual syntax to facilitate validation of data models and complex rules with nontechnical domain experts. DatalogLB is an extended form of typed datalog that exploits fact-oriented data structures to provide deep and highly performant support for complex rules with guaranteed decidability. This paper provides an overview of recent research and development efforts to extend the Natural ORM Architect (NORMA) software tool to map ORM models to DatalogLB.

A Role Calculus for ORM

A conceptual schema of an information system specifies the fact structures of interest as well as related business rules that are either constraints or derivation rules. Constraints restrict the possible or permitted states or state transitions, while derivation rules enable some facts to be derived from others. Graphical languages are commonly used to specify conceptual schemas, but often need to be supplemented by more expressive textual languages to capture additional business rules, as well as conceptual queries that enable conceptual models to be queried directly. This paper describes research to provide a role calculus to underpin textual languages for Object-Role Modeling (ORM), to enable business rules and queries to be formulated in a language intelligible to business users. The role-based nature of this calculus, which exploits the attribute-free nature of ORM, appears to offer significant advantages over other proposed approaches, especially in the area of semantic stability.

Automated invariant maintenance via OCL compilation

UML design models, specifically their declarative OCL invariants, must be refined into delivered code. A key problem is the need to integrate this logic with programmer-written code in a non-intrusive way. We recently developed an approach, called mode components, for compiling OCL constraints into modules that implement logic for transparently maintaining these constraints at run time. Specifically, mode components are implemented as nested C++ class template instantiations. The approach makes use of a key device-status variables. The attributes of a component to which other components are sensitive are called its status. A status variable is a lightweight wrapper on a status attribute that detects changes to its value and transparently invokes a method to handle announcements to dependent components. A mode component is a wrapped code unit containing one or more status variables. The contribution of this paper is a technique for achieving this integration using metaprogramming techniques.

Live logic programming

Logic programming languages are today used to build applications accessing large database systems. This raises the possibility of building live development environments for them. Of particular interest is how specific language features such as level of abstraction, transactions, etc. affect the design of such an environment. In this paper, we explore this question for a specific logic language, Datalog, contrast traditional and live approaches for its tooling and discuss issues that arise.

PATCH—a new algorithm for rapid incremental dependence analysis

Dependence analysis is critical to tools for parallel programming such as compilers, parallelizers, and performance analyzers. Conventional algorithms and data structures for dependence analysis are complex and time consuming, requiring multiple passes. In addition, these algorithms cannot easily be adapted to incrementally recompute dependence after program modifications. In this paper we present a new approach to dependence analysis which computes dependence in linear time (no backtracking) with a low space overhead. The algorithm handles arbitrary, unstructured control flow and calls to subprograms whose dependence have not been analyzed, and can be extended to allow very rapid incremental dependence recomputation. The algorithms are currently being implemented in PAT, a portable parallelization tool.