Current visualization methods emphasize a literal view of computation, mapping system components to individual visualization elements. This approach is insufficient for analyzing complex parallel and distributed concurrent systems: (1) the visualization fails to present an abstract view of system interaction; (2) it artificially differentiates between conceptually equivalent component interactions; and (3) visualization is not practically scalable. Thus, a literal view, while feasible in small-scale systems, is not suitable for large-scale ones. We are developing linguistic support for behavioral animation which allows a high-level specification of component interactions.

Concurrent object-oriented languages are attractive for portable programming because they support modularity and reuse. Our goal is to support a natural object-oriented programming style for parallel programs. Compilation research includes interprocedural type inference, aliasing analysis, procedure cloning, and inlining as well as compilation for locality, efficient support of both multithreading and stack-based execution. Runtime issues include object-based caching, data placement and migration, scheduling, and portability across distributed memory, shared memory, and workstation cluster-based parallel computers. We have released three major versions of the Concert system, and achieved high performance both on sequential benchmarks and entire parallel applications.

The objective of Transframe is to support rapid prototyping and delivery of embedded applications in a single language framework. The Transframe language provides a dynamically typed environment to support rapid prototyping and reuse of applications modules (frameworks). The implementation allows types to be incrementally refined, and the implementation exploits the declarations to achieve high performance.

Term-rewriting systems are a general programming language with simple, elegant syntax and semantics. We have invented various useful classes of orderings for proving termination and are also investigating methods of proving other properties of rewrite systems. In addition, applications of rewrite systems to theorem-proving, equation solving, programming language semantics and theory of computation are being investigated. Conditional rewriting is an active area of current research; we are looking at its application to logic programming and constraint satisfaction systems, as well as theoretical issues.

ACSL is a collaborative venture with the U.S. Army Corps of Engineers and our industrial sponsors. The goal of our research is the development of next-generation environments to address the complex issues associated with understanding and supporting collaborative engineering processes. A particular focus of our work is the development of knowledge-based tools that support collaborative software development processes; this should be viewed as a prototypical area of endeavor rather than a closure of our interests. Our research has three major thrusts: models and technologies for the support of collaborative activities; development and application of knowledge-based theories and methodologies to increase the level of support that can be provided to users; and development of advanced user interface management systems.

We have devised a syntactic error recovery scheme for programming languages. The scheme is based on LR parsing and is driven by information that is directly and automatically obtainable from the LR tables. The method shows good promise for providing excellent error diagnostics. In continuing work, we wish to improve the efficiency of the method and to relate the mechanism to other parsing schemes.

In this project we are developing a generalized shift-reduce parser generating system which allows interactive generation and modification of noncanonical LR-style parsers. This is coupled with a tree evaluator which provides interpretive execution of an attribute-like semantics for the language. This will be used as a tool to produce parsers for unconventional languages, to experiment with error recovery techniques, and to investigate aspects of parallel parsing.

In this project we are investigating techniques for compiling in parallel. We have devised an extension to standard shift-reduce parsing, called ``piecewise'' LR parsing, which permits multiple parsers to be situated at arbitrary places in an input string. Using such piecewise LR parsers, we have demonstrated that it is not only possible to parse in a truly parallel fashion, but that significant speedup can often be achieved. Our continuing goal is to characterize the class of languages acceptable by such parsers, and to devise unconventional programming language constructs which exploit the power of the technique.

We are investigating type systems and typed programming methodologies for logic programming. A type system called Typed Prolog has been defined as a polymorphically typed version of Prolog. A type inference system for the language has been implemented and widely distributed by ftp. Our focus is currently on combining type and mode information to express the input-output behavior of logic programs. This form of information forms the foundation for arguing about termination and complexity properties of logic programs. It also allows us to reason about deadlock-freedom and multiwrite failures in concurrent logic programs. We are looking at the application of Girard's linear logic to express this kind of combined type and mode information.