4th USENIX Conference on Object-Oriented Technologies and Systems (COOTS)

Santa Fe, New Mexico
April 27-30, 1998

Summaries by Irfan Pyarali
<irfan@cs.wust.edu>

Photos by Joe Hoffert
<joeh@cs.wust.edu>

Published in ;login;, vol. 23, no. 4, August 1998.

Once the Spanish and Mexican capital of the region, Santa Fe is like no other city on earth. At an elevation of about 7,000 feet (2,135 meters) above sea level, Santa Fe is at the point where the high desert meets the ponderosa pine and aspen forests of the Sangre de Cristo Mountains, which rise to over 12,000 feet (3,660 meters) within a half-hour's drive of town. In addition to providing a beautiful setting for outdoor activities, Santa Fe is well known as a center of art and culture, with numerous galleries, museums, opera and chamber music. Although Santa Fe is the state capital of New Mexico, it is not the largest city. With a population of approximately 70,000, it retains a charming "small town" feeling. The first USENIX C++ workshop was held here in 1987; this conference series was converted to COOTS in 1995.

When attendees were not enjoying Santa Fe, they were hearing about recent advances in tools, languages, frameworks, components, and patterns in the conference rooms of the Eldorado Hotel. Most of the technical sessions focused on the increasing demands of distributed computing, with Java stealing the show. Joseph Sventek of Hewlett-Packard Laboratories was this year's program chair. The tutorial program chair was Douglas C. Schmidt of Washington University. Session topics and tutorials

focused on efficiency, distributed infrastructure and services, mobility, programming techniques, and distributed object computing models such as CORBA, DCOM/MTS, Java RMI, and Java Beans.

WELCOME NOTE

Joseph Sventek opened the conference with a welcome note to the 220 attendees. He was pleased to announce that 56 papers were submitted for review this year; 18 papers were accepted to the conference, of which the top five would appear in the Distributed Systems Engineering Journal. Joe thanked all the USENIX staff and conference organizers for their hard work in putting this event together. He then awarded Prashant Jain, late of Washington University and now at Fujitsu, the best student paper award for "Design and Performance of MedJava." Joe also promised to raffle off books that were on exhibition at the conference as a bribe so that attendees would stay until the end of the conference.

KEYNOTE ADDRESS

Rick Rashid, late of CMU/Mach and now vice president of Microsoft Research, gave this year's keynote address, entitled "The Shape of Things to Come." He described the changing role of computers from monolithic, immobile, number-crunching, isolated machines to small, mobile, interactive, internetworked devices that will be used for communication, collaboration, and distance learning.

Rick presented various examples of the shape of things to come: (1) virtual meetings from the comfort of your home, (2) natural language processing, including speech recognition and synthetic voices, (3) gesture recognition, (4) virtual worlds for commerce and entertainment, (5) office assistants and answer wizards, and (6) implicit and intelligent help systems. Rick asserts that these kinds of technologies are not far away, pointing out that work on them is under way. In fact, some of these technologies will be supported by the 59 million lines of code in Windows NT 5.0.

Rick acknowledged that applications in the future will be complex and hard to develop. To facilitate the production of these complex applications, developers must rely on underlying middleware frameworks to provide distribution, replication, and reliability. The infrastructure of these systems will support self-describing objects, dynamic monitoring, interceptors, automated distribution, profile-based analysis, and virtual environments through clustering and replication.

Session: Efficiency

The first session of the conference was chaired by Murthy Devarakonda from IBM T.J. Watson Research Center. As distributed systems become ubiquitous and mature, increasing focus is being placed on the efficiency of these systems.

Quality of Service (QoS) Specification in Distributed Object Systems

Svend Frolund and Jari Koistinen, Hewlett-Packard Laboratories

Jari Koistinen started by pointing out that traditional distributed systems do not address QoS aspects, such as reliability, security, and performance. QoS requirements can significantly affect the design of components in the system. Jari introduced QML (QoS Modeling Language), which captures QoS properties as part of the system design.

In addition, Jari explained that some components in a distributed system are used explicitly by clients, whereas other components are used implicitly by system components that are not directly under the QoS contract specified by the client. Distributed components must therefore be QoS-aware and QoS-enabled. The infrastructure must provide negotiations, trading, and monitoring of QoS parameters. QoS-based trading services can be used to find appropriate services via dynamic matching of clients and servers.

Efficient Implementation of Java Remote Method Invocation (RMI)

Vijaykumar Krishnaswamy, Dan Walther, Sumeer Bhola, Ethendranath Bommaiah, George Riley, Brad Topol, and Mustaque Ahamad, Georgia Institute of Technology

Interactive distributed applications require fast response and low latency. However, applications written in Java RMI have not met these requirements. Vijaykumar Krishnaswamy described the optimizations that make RMI more feasible for these kinds of applications. These optimizations are based on transparent caching of server objects at clients when the object changes state only infrequently. In this case, invocations can be local and do not require network communications. However, caching does require consistency protocols to make the cached objects consistent when the state of the object changes.

Vijaykumar then described experimental results that show how the caching system behaves in various client/server configurations. He showed that, as the network latency between the client and the server increases, caching pays off. However, when the cache is invalidated often, the performance is severely degraded. His approach did require the object implementor to tag operations on the object that did change the state of the object. He concluded that the RMI framework can be easily extended to support caching of objects. Moreover, point-to-point messaging between the client and server could be easily changed to employ group communication using a multicast protocol.

The Design and Performance of MedJava

Prashant Jain, Seth Widoff, and Douglas C. Schmidt, Washington University

Prashant Jain, who was at Washington University when he wrote this paper and is now at Fujitsu, began by outlining the goals of an Electronic Medical Imaging System (EMIS). He described the challenges of designing and developing an EMIS that must be reusable, efficient, reliable, flexible, and scalable. He justified the use of Java for this project by pointing out that Java is object oriented,

portable, distributed, and secure, with built-in support for threading and networking. In addition, Java has many standard libraries, and numerous Java-enabled browsers are freely available.

The EMIS Prashant developed was designed so the server contained the image repository and filter repository, while the client contained a graphical user interface, a URL locator, an image processor, a component for uploading and downloading of images, and a filter configurator. Filters can be used to view different aspects of an image, for example, to sharpen, enlarge, and edge enhancement.

After this overview, Prashant compared the image processing based on Java with that of an image-processing toolkit based on C. In some cases, the Java-based image-processing toolkits outperformed the C-based toolkits. In general, however, the C-based image-processing toolkit outperformed the Java version due to the statically compiled/optimized nature of C applications. In conclusion, Java performed surprisingly well for image processing and network transport.

Prashant Jain's Best Student Paper Award is accepted by coauthor Doug Schmidt

Session: Distributed Infrastructure

As Rick Rashid had pointed out in the keynote address, complicated applications of the future will demand lots of features from the underlying infrastructure, such as distribution, replication, and security. This session, chaired by Steve Vinoski of IONA Technologies, focused on distributed infrastructures.

Dynamic Management of CORBA Trader Federation

Djamel Belaid, Nicolas Provenzano, and Chantal Taconet, Institut National Des Telecommunications

The authors' work on the CORBA trading service, presented by Chantal Taconet, was an extension of the CORBA specification. Session chair Steve Vinoski promptly criticized COOTS program chair Joe Sventek, who was largely responsible for devising the CORBA trading service, for providing an incomplete specification.

The trading service helps clients find the "right" object in a distributed system. The right object is typically found based on properties of interest to the client. In CORBA, objects are located by services like naming or trading. In the trading service, object implementors register object properties with the trading service. On the other side, the client specifies the properties it is interested in. The trading service is responsible for finding the appropriate matches for the client. Traders are usually federated to provide distributed lookup services to clients.

In the CORBA specification, each trader has a local view of the trader graph (i.e., it knows only about its neighbors). The default CORBA trader has the following drawbacks: (1) no concept of nearest object to client, (2) no provision for trader failures, and (3) manual establishment of trader links. Chantal then described the Dynamic Federation Graph (DFG), where the graph is globally known in the entire system, there are no cycles in the graph, and communication load is dynamically and automatically distributed among the traders. Each trader is enhanced to support a DFG. Traders use a different management interface to keep the DFG information consistent. These extensions are transparent to the exporters and the importers.

Filterfresh: Hot Replication of Java RMI Server Objects

Arash Baratloo, New York University; P. Emerald Chung, Yennun Huang, Sampath Rangarajan, and Shalini Yajnik, Lucent Technologies, Bell Laboratories

The primary goal of the Filterfresh project was to provide high availability of Java services, protect the clients from server failures, and transparently replicate services and data. Filterfresh used a fault tolerance approach based on process groups, such that the group members have a consistent view of the state of the system. The system was developed using UDP, and all events in the system are reliable and totally ordered. Experiments showed that under certain conditions local RMI was slower than remote RMI. It also showed that Java threading and synchronization were the leading cause of bottlenecks in the system.

COMERA: COM Extensible Remoting Architecture

Yi-Min Wang, Microsoft Research; Woei-Jyh Lee, New York University

Yi-Min Wang presented this work. The current COM architecture allows semicustom marshalling, custom marshalling, and RPC transport replacement. However, most of the customization can be done only at a fairly coarse-grain level, which allows only wholesale changes to be made. COMERA allows fine-grain customization of COM middleware at various different granularities and abstraction levels. These customizations allow multi-connection channels that can be used to implement replication. These customizations can also be used to implement object failover. However, there are many open issues about security, recursive extensibility, and manageability of such a system.

Session: Distributed Services

This session was chaired by Rajendra Raj from Morgan Stanley.

Java Transactions for the Internet

M.C. Little and S.K. Shrivastava, University of Newcastle

The Web frequently suffers from failures that affect the performance and consistency of applications running over it. With the advent of Java, it is now possible to include thin clients (such as browsers) in transactions to provide fault tolerance and consistency in the presence of failures.

Little and Shrivastava have developed a transactional toolkit for Java called JTSArjuna. JTSArjuna provides persistence, concurrency, crash recovery, and object replication. In addition, JTSArjuna provides distributed transactions and a high-level API that glues together the low-level details for managing an Object Transaction Service (OTS). The configurable hierarchy of classes in JTSArjuna provides flexibility to the clients in transactional domains.

Secure Delegation for Distributed Object Environments

Nataraj Nagaratnam, Syracuse University; Doug Lea, State University of New York, Oswego

Secure delegation occurs when one object authorizes another object to access services and resources on its behalf. The Secure Delegation Model (SDM) extends current Java security features to support secure remote method invocation that may involve chains of delegated calls across distributed objects. Security policies may be controlled explicitly in application code or implicitly via administrative tools.

COBEA: A CORBA-Based Event Architecture

Chaoying Ma and Jean Bacon, University of Cambridge

Chaoying Ma started by describing the concept of events in distributed systems. Events contain descriptions of changes in the system and can be used to model asynchronous communications where the sender and the receiver can to be decoupled. She also described how event channels can be used to architect pull- and push-based systems. COBEA provides parameterized filtering, reliability, and security. COBEA also has a language to specify composite events. Chaoying concluded by providing some performance results and describing her initial experiences in developing COBEA.

Session: Experience Papers

This session was chaired by Douglas C. Schmidt from Washington University. Perhaps as a sign of the times, all the papers covered techniques for effectively using Java in real, large-scale projects.

Objects and Concurrency in Triveni: A Telecommunication Case Study in Java

Christopher Colby, Loyola University; Lalita Jategaonkar Jagadeesan, Lucent Technologies, Bell Laboratories; Radha Jagadeesan and Konstantin Laufer, Loyola University; Carlos Puchol, Lucent Technologies, Bell Laboratories

Triveni is language-independent architecture that supports systems based on finite state machines. The Triveni framework supports concurrent programming with threads and events. Programs can be freely combined using Triveni combinators. Konstantin Laufer's presentation focused on realizing Triveni in Java. A Triveni program is usually a combination of an Observable, an Observer, and a Runnable. The framework has built-in support for composing parallel tasks, event multicast, and event ordering. The next version of Triveni will include support for distributed programming in the form of Java RMI. Future work will also include mobility and support for exception and priorities.

An Object-Oriented Framework for Distributed Computational Simulation of Aerospace Propulsion Systems

John A. Reed and Abdollah A. Afjeh, University of Toledo

Designing and developing new aerospace propulsion systems is time-consuming and expensive. Onyx is a Java-based object-oriented application framework for aerospace propulsion system simulation that supports finite element analysis and computational fluid dynamics. For computationally intensive analysis, Onyx components can be distributed across a heterogeneous system. Complicated propulsion components are designed using the composite pattern. Multidimensional design supports increasing levels of details for the simulation.

Building a Scalable and Efficient Component Oriented System using CORBA ­ Active Badge System Case Study

Jakub Szymaszek, Andrzej Uszok, and Krzysztof Zielinski, University of Mining and Metallurgy, Kracow

Andrzej Uszok presented this paper. The Active Badge next generation (ABng) project is a localization system for an office environment. Used to control office and home appliances, ABng provides location and hardware abstractions, event filtering, and security. Event notifications in the system are based on the Observer pattern. The system is written in Java and CORBA.

Session: Mobility

This session was chaired by Doug Lea from the State University of New York (SUNY), Oswego.

Mobile Objects and Agents (MOA)

Dejan S. Milojicicc, William LaForge, and Deepika Chauhan, The Open Group Research Institute

MOA was designed to support migration, communication, and control of agents. It was implemented on top of the Java Virtual Machine, without any modifications to it. The initial project goals were to support communication across agent migration as a means for collaborative work and to provide extensive resource control as a basic support for countering denial of service attacks.

In the course of the MOA project, two further goals were added: (1) compliance with the Java Beans component model that provides for additional configurability and customization of agent system and agent applications and (2) interoperability that allows cooperation with other agent systems. The MOA architecture was analyzed, with particular attention being paid to the support for mobility, naming and locating, communication, and resource management. Object and component models of MOA were discussed and some implementation details described.

Programming Network Components Using NetPebbles: An Early Report

Ajay Mohindra, Apratim Purakayastha, Deborra Zukowski, and Murthy Devarakonda, IBM T.J. Watson Research Center

Developers of networkcentric applications face a number of challenges, including distributed program design, efficient remote object access, software reuse, and program deployment issues. This level of complexity hinders the developer's ability to focus on the application logic. NetPebbles removes this complexity from the developer through a network component-based scripting environment where remote object access and program deployment are transparent to the developer.

In the NetPebbles programming model, developers select network components from a distributed catalog and then write a script invoking component methods as

if the components were local. When the script is launched, the Netpebbles runtime determines the component sites in the network and transparently moves the script as needed. Using three simple examples with different data flow patterns, the NetPebbles approach was shown to be superior to the traditional client/server systems and mobile agent technologies because a scripting language is easy to use, it requires less code, and the distributed systems complexity is hidden from the programmer.

The Architecture of a Distributed Virtual Worlds System

Manny Vellon, Kirk Marple, Don Mitchell, and Steven Drucker, Microsoft Research

The Virtual World project provides an object model that facilitates the development of shared virtual environments. The project is implemented on top of COM and OLE Automation and allows access from active scripting-enabled languages. The platform provides features that handle client/server computing, persistent state management, security, and ease of development.

Session: Programming Techniques

The final session was chaired by Jennifer Hamilton from Microsoft Corporation.

Execution Patterns in Object-Oriented Visualization

Wim De Pauw, David Lorenz, John Vlissides, and Mark Wegman, IBM T.J. Watson Research Center

Execution patterns are a new metaphor for visualizing execution traces of object-oriented programs. An execution pattern lets a programmer visualize and explore a program's execution at varied levels of abstraction. The view employs visual, navigational, and analytical techniques that accommodate lengthy, realworld traces. Execution patterns enhance object-oriented visualization in three ways: (1) object communications can be visualized, (2) similar execution patterns can be generalized, and (3) it provides a foothold for characterizing system complexity. By classifying repetitive behavior automatically into high-order execution patterns, they drastically reduce the information a programmer must assimilate, with little loss of insight.

IBDL: A Language for Interface Behavior Specification and Testing

Sreenivasa Viswanadha and Deepak Kapur, State University of New York, Albany

Interface Behavior Description Language (IBDL) is a methodology and language for specifying behaviors of interfaces for object-oriented systems and is based on the message-passing paradigm. Signatures of messages are enhanced to include semantic information, expressing behavior clients can expect from a server. Formulas are given to distinguish normal termination from abnormal termination of a message using the return values and exceptions to reflect whether the precondition associated with the message is satisfied or not. State changes caused by a message invocation are specified by explicitly enumerating subsequent messages that a message invocation enables and/or disables, by establishing or violating their preconditions. Special operators on sequences of messages are defined to specify such semantic information.

Compile Time Symbolic Derivation with C++ Templates

Joseph Gil, IBM T.J. Watson Research Center; Zvi Gutterman, Technion Israel Institute of Technology

C++ templates are already recognized as a powerful linguistic mechanism whose usefulness transcends the realization of traditional generic containers. In the same venue, this presentation reported on a somewhat surprising application of templates for computing the symbolic derivative of expression. Specifically, they described a software package based on templates, called SEMT, which enables the programmer to create symbolic expressions, substitute variables in them, and compute their derivatives. SEMT is unique in that these manipulations are all done at compile time. In other words, SEMT effectively coerces the compiler to do symbolic computation as part of the compilation process. Beyond the theoretical interest, SEMT can be practically applied in the efficient, generic, and easy-to-use implementation of many numerical algorithms.

Panel: Web Versus Distributed Objects

The Web versus distributed objects panel

The panel of this year's COOTS conference was Web versus distributed objects, moderated by Ken Arnold from Sun Microsystems. The panelists were Rohit Khare from the University of California, Irvine, Joe Kiniry from the California Institute of Technology, and Jim Waldo from Sun Microsystems.

Ken began with a history of computing starting all the way back to punch cards, to object-oriented computing, and then jumping to the Web. Jim observed that the Web is full of objects that need to move around. As these objects move, they must move around with their code. This means that there was need for portable object code, safety and verification, user and code identity, and authentication. At this point, no one in the audience could tell that Jim was trying to promote Java.

The Web has always been easy to work with and use and very inexpensive to develop on. Even though the Web namespace is crummy and the protocols used are inefficient, it works. The common consensus was: just increase the network's bandwidth and everything will be OK. The conclusions from the panel were that the Web should be used for what it is good for (publishing information, user interface), and object systems should be used for more structured information exchange such as trading and mobility.

CLOSING REMARKS

Joe Sventek concluded the proceedings by thanking the attendees, the program committee, and the USENIX staff. He then introduced Murthy Devarakonda, who is the program chair for COOTS '99. Overall, COOTS '98 was a great conference with lots of novel and interesting papers and presentations. We look forward to seeing you next May in San Diego.