Bharat Jayaraman

Methodology and architecture of JIVE

A novel approach to the runtime visualization and analysis of object-oriented programs is presented and illustrated through a prototype system called JIVE: Java Interactive Visualization Environment. The main contributions of JIVE are: multiple concurrent representations of program state and execution history; support for forward and reverse execution; and graphical queries over program execution. This model facilitates program understanding and interactive debugging. Our visualization of runtime states clarifies the important point that objects are environments of execution. The history of object interaction is displayed via sequence diagrams, and in this way we help close the loop between design-time and run-time representations. Interactive execution is made possible by maintaining a runtime history database, which may be queried for information on variable behavior, method executions, and object interactions. We illustrate the capabilities of this system through examples. JIVE is implemented using the Java Platform Debugger Architecture and supports the Java language and libraries, including multithreaded and GUI applications.

Implementation of subset-equational programs

Abstract This paper discusses issues in a sequential implementation of a subset-equational language, an extension of the equational programming paradigm for efficient treatment of set-valued functions. Subset assertions have the form f ( terms )⊇ expression , and in general, multiple subset assertions may be used to define a set-valued function f . They incorporate a collect-all capability, so that the meaning of a set-valued function f applied to argument terms is equal to the union of the respective sets defined by the different subset assertions for f . The universe of terms also includes set-valued terms; hence the matching operation between terms is set matching . The multiple matches arising from set matching effectively serve to iterate over the elements of sets, thus permitting many useful set operations to be stated nonrecursively. The main features of this implementation are: (1) compiling the commonly occurring forms of set patterns using instructions similar to the WAM instructions for PROLOG ; (2) avoiding checks for duplicates and construction of intermediate sets in argument positions of functions when they distribute over union in these arguments; and (3) performing last-call optimization for both equational and subset assertions. An implementation of these ideas has been completed, and compiled code for typical program fragments is presented, as well as performance figures for the key optimizations.

A comparison of B2B e-service solutions

The Internet is evolving not only to provide information and e-commerce transactions, but also to act as the platform through which services are delivered to businesses and customers. These electronic services or e-services could become a key part of the value provided by many businesses [2, 5, 10]. At the core of this evolution is Extensible Markup Language (XML), which has emerged as the foundation of all architectures suggested for such services. XML simplifies the exchange of information by letting users define their own syntax and use underlying technologies of the Internet. However, while organizations can define XML syntax to solve their specific problems, the multitude of syntax (schemas) creates incompatibility problems with schemas developed by others. This is one of the reasons why major organizations are creating business-to-business (B2B) XML framework standards to enable interoperability. To overcome these problems, efforts are underway to develop standards for e-services including eCo by a consortium led by CommerceNet; RosettaNet by a consortium that includes IBM, Microsoft, EDS, SAP, Cisco systems, Compaq and Intel; BizTalk by Microsoft; e-speak by Hewlett Packard (HP), and several others. Since these B2B interoperability standards are likely to be very important in the way businesses interact with each other in the future, an overview of these standardization efforts is certain to be of considerable importance to the IS community. This article describes the components (core modules of platforms for linking Internet-based service providers) of e-services and compares popular B-to-B e-commerce frameworks based on their support for e-service components.

Preference queries in deductive databases

Traditional database query languages such as datalog and SQL allow the user to specify only mandatory requirements on the data to be retrieved from a database. In many applications, it may be natural to express not only mandatory requirements but also preferences on the data to be retrieved. Lacroix and Lavency10) extended SQL with a notion of preference and showed how the resulting query language could still be translated into the domain relational calculus. We explore the use of preference in databases in the setting of datalog. We introduce the formalism of preference datalog programs (PDPs) as preference logic programs without uninterpreted function symbols for this purpose. PDPs extend datalog not only with constructs to specify which predicate is to be optimized and the criterion for optimization but also with constructs to specify which predicate to be relaxed and the criterion to be used for relaxation. We can show that all of the soft requirements in Reference10) can be directly encoded in PDP. We first develop anaively-pruned bottom-up evaluation procedure that is sound and complete for computing answers to normal and relaxation queries when the PDPs are stratified, we then show how the evaluation scheme can be extended to the case when the programs are not necessarily stratified, and finally we develop an extension of themagic templates method for datalog14) that constructs an equivalent but more efficient program for bottom-up evaluation.

Analysis of Or-parallel execution models

We discuss fundamental limitations of or-parallel execution models of nondeterministic programming languages. Or-parallelism corresponds to the execution of different nondeterministic computational paths in parallel. A natural way to represent the state of (parallel) execution of a nondeterministic program is by means of an or-parallel tree. We identify three important criteria that underlie the design of or-parallel implementations based on the or-parallel tree: constant-time access to variables, constant-time task creation, and constant-time task switching, where the term constant-time means that the time for these operations is independent of the number of nodes in the or-parallel tree, as well as the size of each node. We prove that all three criteria cannot be simultaneously satisfied by any or-parallel execution model based on a finite number of processors but unbounded memory. We discuss in detail the application of our result to the class of logic programming languages and show how our result can serve as a useful way to categorize the various or-parallel methods proposed in this field. We also discuss the suitability of different or-parallel implemenation strategies for different parallel architectures.

JIVE: java interactive visualization environment

Jive represents a novel approach to runtime visualization and analysis of Java programs. It facilitates program understanding and interactive debugging, featuring: multiple, customizable views of object structure; representation of execution history via sequence diagrams; interactive queries on runtime behavior; forward and reverse interactive execution. JIVE uses standard JVM and compilers.

And—or parallelism on shared-memory multiprocessors

Abstract This paper presents an extended and—or tree and an extended WAM (Warren Abstract Machine) for efficiently supporting both and-parallel and or-parallel execution of logic programs on shared-memory multiprocessors. Our approach for exploiting both and- and or-parallelism is based on the binding-arrays method for or-parallelism and the RAP (Restricted And-Parallelism) method for and-parallelism, two succesful methods for implementing or-parallelism and and-parallelism, respectively. Our combined and—or model avoids redundant computations when goals exhibit both and- and or-parallelism, by representing the cross product of the solutions from the and—or parallel goals rather than recomputing them. We extend the classical and—or tree with two new nodes: a “sequential” node (for RAPs sequencial goals), and a “cross-product” node (for the cross product of solutions from and—or parallel goals). The paper also presents an extension of the WAM, called AO—WAM, which is used to compile logic programs for and—or parallel execution based on the extended and—or tree. The AO—WAM incorporates a number of novel features: (i) inclusion of a base array with each processors binding array for constant-time access to variables in the presence of and-parallelism, (ii) inclusion of new stack frames and instructions to express solution sharing , and (iii) novel optimizations which minimize the cost of binding-array updates in the presence of and-parallelism.

Scoping constructs in logic programming: Implementation problems and their solution

The inclusion of universal quantification and a form of implication in goals in logic programming is considered. These additions provide a logical basis for scoping, but they also raise new implementation problems. When universal and existential quantifiers are permitted to appear in mixed order in goals, the devices of logic variables and unification that are employed in solving existential goals must be modified to ensure that constraints arising out of the order of quantification are respected. Suitable modifications that are based on attaching numerical tags to constants and variables and on using these tags in unification are described. The resulting devices are amenable to an efficient implementation and can, in fact, be assimilated easily into the usual machinery of the Warren Abstract Machine (WAM). The provision of implications in goals results in the possibility of program clauses being added to the program for the purpose of solving specific subgoals. A naive scheme based on asserting and retracting program clauses does not suffice for implementing such additions for two reasons. First, it is necessary to also support the resurrection of an earlier existing program in the face of backtracking. Second, the possibility for implication goals to be surrounded by quantifiers requires a consideration of the parameterization of program clauses by bindings for their free variables. Devices for supporting these additional requirements are described as also is the integration of these devices into the WAM. Further extensions to the machine are outlined for handling higher-order additions to the language. The ideas presented here are relevant to the implementation of the higher-order logic programming language λProlog.

Declarative and visual debugging in Eclipse

We present a declarative and visual debugging environment for Eclipse called JIVE.1 Traditional debugging is procedural in that a programmer must proceed step-by-step and object-by-object in order to uncover the cause of an error. In contrast, we present a declarative approach to debugging consisting of a flexible set of queries over a programs execution history as well as over individual runtime states. This runtime information is depicted in a visual manner during program execution in order to aid the debugging process. The current state of execution is depicted through an enhanced object diagram, and the history of execution is depicted by a sequence diagram. Our methodology makes use of these diagrams as a means of formulating queries and reporting results in a visual manner. It also supports revisiting past runtime states, either through reverse stepping of the program or through queries that report information from past states. Eclipse serves as an ideal framework for implementing JIVE since, like the JIVE architecture, it makes crucial use of the Java Platform Debugging Architecture (JPDA). This paper presents details of the JIVE architecture and its integration into Eclipse.

Multimodal identification and tracking in smart environments

We present a model for unconstrained and unobtrusive identification and tracking of people in smart environments and answering queries about their whereabouts. Our model supports biometric recognition based upon multiple modalities such as face, gait, and voice in a uniform manner. The key technical idea underlying our approach is to abstract a smart environment by a state transition system in which each state records a set of individuals who are present in various zones of the environment. Since biometric recognition is inexact, state information is inherently probabilistic in nature. An event abstracts a biometric recognition step, and the transition function abstracts the reasoning necessary to effect state transitions. In this manner, we are able to integrate different biometric modalities uniformly and also different criteria for state transitions. Fusion of biometric modalities is also supported by our model. We define performance metrics for a smart environment in terms of the concepts of ‘precision’ and ‘recall’. We have developed a prototype implementation of our proposed concepts and provide experimental results in this paper. Our conclusion is that the state transition model is an effective abstraction of a smart environment and serves as a good basis for developing practical systems.