• Publications
  • Influence
Transformations for model checking distributed Java programs
This paper describes three program transformations that extend the scope of model checkers for Java programs to include distributed programs, i.e., multi-process programs. The transformations combine
Static caching for incremental computation
The cache-and-prune method presented in the article consists of three stages: the original program is extended to cache the results of all its intermediate subcomputations as well as the final result, the extended program is incrementalized so that computation on a new input can use all intermediate results on an old input.
From clarity to efficiency for distributed algorithms
A very high-level language for clear description of distributed algorithms and optimizations necessary for generating efficient implementations of logic quantifications and new optimizations are presented that automatically transform complex synchronization conditions into incremental updates of necessary auxiliary values as messages are sent and received.
Parametric regular path queries
The paper describes the specification, design, analysis, and implementation of algorithms and data structures for efficiently solving existential and universal parametric regular path queries, and investigates the efficiency tradeoffs between different formulations of queries.
From datalog rules to efficient programs with time and space guarantees
This paper describes a method for transforming any given set of Datalog rules into an efficient specialized implementation with guaranteed worst-case time and space complexities, and for computing
Eliminating dead code on recursive data
Automatic Accurate Time-Bound Analysis for High-Level Languages
The approach consists of transformations for building time-bound functions in the presence of partially known input structures, symbolic evaluation of the time- bound function based on input parameters, optimizations to make the overall analysis efficient as well as accurate, and measurements of primitive parameters, all at the source-language level.
Core role-based access control: efficient implementations by transformations
This paper describes a transformational method applied to the core component of role-based access control (RBAC), to derive efficient implementations from a specification based on the ANSI standard for RBAC, and describes successful prototypes and experiments for the efficient implementations and for automatically generating efficient implementation from straightforward implementations.
Generating incremental implementations of object-set queries
A general and powerful method for automatically generating incremental implementations of high-level queries over objects and sets in object-oriented programs, where a query may contain arbitrary set enumerators, field selectors, and additional conditions is described.
Incremental Computation: A Semantics-Based Systematic Transformational Approach
This research focuses on identifying the fundamentals of efficient incremental computation out of domain-specific properties and language-specific features, devising a general framework that accommodates these fundamentals, and developing a systematic approach based on the framework that exploits program semantics.