The following papers have been selected for inclusion in the TOOLS USA '98 Technical Program by the international Program Committee

Building an OMT-Editor Using Design Patterns: An Experience Report
B. Wydaeghe, K. Verschaeve, B. Michiels, B. Van Damme, E. Arckens, and V. Jonckers, Vrije Universiteit Brussel, Belgium

This paper discusses the development and implementation of a customizable editor for OMT/UML style object-models and behavior-models. A number of well known design patterns are used to obtain a flexible architecture that allows to build tool support for our software engineering research requiring variants or add-ons to the basic editors. We report on the difficulties we encountered in applying these design patterns and we evaluate the claims of improved flexibility, modularity, reusability, and understandability as stated in the design pattern literature in general.

An Object-Oriented Framework for Local Search Heuristics
A.A. Andreatta, University of Rio de Janeiro, Brazil, S.E.R. Carvalho, and C.C. Ribeiro, PUC-Rio, Brazil

In the study of heuristics for hard combinatorial problems (such as  the Traveling Salesman Problem or the Steiner Tree Problem, to cite two among many), it is often important to develop and compare systematically different algorithms, strategies, and parameters for the same problem. This comparison is often biased not only by different implementation languages, but also by different design architectures. This paper proposes a framework, described using design patterns, modeling different aspects involved in local search heuristics, such as algorithms for the construction of initial solutions, methods for neighborhood generation, and movement selection criteria. Using this framework, we fix a basic architecture and thus increase our ability to construct and compare heuristics.

Practical Rules for Reducing the Number of States of a State Diagram
J. Ma and S. Yu, University of Western Ontario, Canada

Many object-oriented modeling methods adopt state-based formalisms to specify the behavior of objects. State-based formalisms, pioneered by David Harel, are a powerful and et intuitive tool in modeling the dynamics of objects. However, when a real world object has a huge number (or an infinite number) of states, we usually have to map them into a relatively small number of states in practice. This mapping has been done intuitively and heuristically by software designers. There has not been a set of general and systematic rules for this mapping.

In this paper, we focus on exploring a set of such rules with which a system of a large number (or an infinite number) of states can be transformed systematically into an equivalent finite-state system with a smaller number of states. Examples are given and the suggested rules are explained.

Modeling Dynamic Component Interfaces
B. Rumpe, A. Rausch, and F. Huber, Munich University of Technology, Germany

Finding the right interfaces and abstractions is today one of the most crucial and important challenges in software development. However, we today still do not have optimal concepts to describe interfaces of our software components. This often leads to inappropriate interface definitions, that are messleading in their contained information and therefore prohibit appropriate reuse. In order to improve this situation, the paper defines a more liberal technique to describe the dynamically accessible interfaces of object-oriented components.

Library Interoperability via Inheritance
J. Potter, R. Shelswell, and I. Joyner, Microsoft Research Institute, Macquarie University, Australia

To allow Eiffel programs to run on the Java Virtual Machine we have adopted a translation scheme which addresses issues of library interoperability for the two languages. In this paper we describe an approach which permits Eiffel code to inherit Java code directly, rather than adopt a more conventional external call mechanism. With this approach we can choose to access the Java code as descendants or as clients. In effect we are able to make the Java classes appear directly as Eiffel classes. In particular we can program applets in Eiffel just as a Java programmer does, inheriting directly from the applet class provided by the system, and redefining appropriate routines.

In addition, where Eiffel library classes are implemented with external calls provided by the Eiffel run-time, our translator is able to mix its translated code with Java implementations of the run-time functions.

This ability to inherit Java code in the Eiffel source, and to use inherited versions of Eiffel run-time code on the Java side allows us to utilise both Eiffel and Java libraries in JVM-targetted Eiffel programs.

A Protocol Based Approach to Specifying Interoperability Between Objects
I. Cho, Clemson University, USA; J. McGregor, Clemson University & Software Architects, USA; and L. Krause, Modus Operandi, USA

Interoperability is the ability of two or more software modules to communicate and cooperate with each other. The interoperability problem arises when software developers want to reuse legacy software systems, or when software systems are componentized and these components need to be connected in order to work together.

Traditionally, interoperability checking is performed by signature matching between an invoking function and a function being invoked. Function level signature matching techniques are not sufficient for software components in object oriented systems since an object encapsulates a set of data and functions, and a component may contain more than one object. In this paper we first describe the interoperability problems of software modules both in the procedural and object oriented paradigms, and then review current approaches and compare them.

Based on the review, we propose a new interoperable component model (ICM) that enhances software reusability and maintainability.

Collection Types and Implementations in Object-Oriented Software Libraries
G. Menger, J.L. Keedy, M. Evered, and A. Schmolitzky, University of Ulm, Germany

Collection classes (sometimes called container classes) such as sets and lists allow arbitrary objects to be treated as a collection. They are ideal candidates for software reuse and therefore have an important role in the development and use of object-oriented class libraries. An analysis of representative examples intended for practical use reveals some typical deficiencies from the viewpoint of usability which arise because insufficient attention has been paid to basic principles of software engineering. In particular we identify a number of independent concepts relevant for the design of collection libraries and argue for treating them orthogonally in order to improve usability. Although most of the critical points are well known, newer object-oriented languages do not completely support all the relevant concepts. We indicate to what extent our proposals can be realized, and what remains as a challenge for the design of future languages.

Declarative Reasoning about the Structure of Object-Oriented Systems
R. Wuyts, Vrije Universiteit Brussel, Belgium

The structure of object-oriented systems typically forms a complicated, tangled web of interdependent classes. Understanding this implicit and hidden structure poses severe problems to developers and maintainers who want to use, extend or adapt those systems. This talk will advocate the use of a logic meta-language to express and extract structural relationships in class-based object-oriented systems. This is done by introducing the logic meta-language SOUL (Smalltalk Open Unification Language), and showing how this language was used to build a declarative framework containing rules for reasoning about the structure of Smalltalk programs. The declarative framework's usefulness is illustrated by expressing different high-level structural relationships such as those described by design patterns.

A Framework for Managing Quality of Service Contracts in Distributed Applications
S. Lorcy, N. Plouzeau, Irisa, France, and J.-M. Jezequel, Irisa/CNRS, France

The continuous growth of the Internet and of networks in general has led the way to distributed applications. Such applications are made of processes interacting over a network by sending and receiving messages. However, designers and implementers of distributed applications have to deal with many difficult problems, such as concurrency control, distributed communication, fault-tolerance, and quality of service management. Finding object-oriented solutions to these problems is a very active topic of research and development.

In this paper we show how design patterns may allow a designer and developer to manage quality of service issues of distributed object interaction (e.g. when an object invokes a method on another remote object). We present a "contract-based execution" framework which helps the application developer in building these mechanisms. As an example of contract-based application, we detail the architecture of a distributed interactive virtual space browser built on our framework/

SableCC, an Object-Oriented Compiler Framework
E.M. Gagnon and L.J. Hendren, McGill University, Canada

In this paper, we introduce SableCC, an object-oriented framework that generates compilers (and interpreters) in the Java programming language.  This framework is based on two fundamental design decisions. Firstly, the framework uses object-oriented techniques to automatically build a strictly-typed abstract syntax tree that matches the grammar of the compiled language and simplifies debugging.  Secondly, the framework generates tree-walker classes using an extended version of the visitor design pattern which enables the implementation of actions on the nodes of the abstract syntax tree using inheritance. These two design decisions lead to a tool that supports a shorter development cycle for constructing compilers.

To demonstrate the simplicity of the framework, we present all the steps of building an interpreter for a mini-BASIC language. This example could be easily modified to provide an embedded scripting language in an application.

On Separation between Interface, Implementation, and Representation in Object DBMSs
Y. Leontiev, M.T. Ozsu, and D. Szafron, University of Alberta, Canada

In this paper we present a model that supports a clean separation between the concepts of interface, implementation, and representation. We present several problems that are difficult to solve in the absence of such separation and describe how the proposed model can be used to provide a solution. We also describe the principles that can be used to implement the proposed model in an existing object-oriented database management system.

Object Life-Cycles in Active Relational Databases
F. Porto, M. Silva, and S. Carvalho, PUC-Rio, Brazil

One of the biggest problems that object-oriented developers face today is having to integrate at the enterprise level, object-oriented applications with widely applied and quality active relational databases. This paper focuses on the issues of mapping object dynamic behavior into active relational databases. We present a technique for expanding active relational databases with object-oriented behavior semantics, extracted from state transition diagrams expressing object life-cycles. We consider states as first class objects, and discuss state class and event inheritance.

Web Based Virtual Oscilloscope for Underwater Acoustic Signals
D. Alderman, N. Callaghan, T. Jones, and G Roberts, Naval Undersea Warfare Center, Division Newport, USA

The Naval Undersea Warfare Center, Division Newport (NUWCDIVNT) has developed a virtual digital oscilloscope that has the unique capability of tapping various nodes of a data stream in a digital signal processor (DSP). The NUWCDIVNPT Virtual Oscilloscope (NVO) is written in Java and is accessible using any web browser. The implementation includes most of the functionality found on an ordinary bench-top oscilloscope. The virtual scope is used to observe exercise data (real time or simulated), and for trouble shooting signal processor hardware via the Internet.

One of the primary design goals for the NVO was to ensure that the design not only met the requirements for processing and displaying data from a DSP, but that the design was easily extensible for other data sources without a major redesign and re-coding effort. Object-oriented design methodologies such as inheritance, encapsulation, data abstraction and polymorphism enabled these design goals to be achieved.

A Virtual Classroom Based on Reusable Object-Oriented Components
A. Gavrilovska, V. Trajkovic, and D. Davcev, St. Kiril and Metodij University, Macedonia

In the paper, an agent based Virtual Classroom is presented. The Classroom represents the interface between students and the Virtual Professor Agent. Vitual Professor Agent is responsible for providing the personalized learning material adapted to student's needs. The granularity of agents enables easy reuse of their software code for different agents introduced in the system.

RASEing Towards a Better Systems Development Tool: The Snowball Experience
M.T. Ersavas, RASE Inc., USA

In this paper, we summarize our experience in developing and using the Snowball Rapid Systems Engineering Tool™. We highlight the techniques we used such as: Rapid Systems Engineering™ (RASE™), Instant Code Generation™, Instant Reverse Engineering™, and Dynamic Document Capture™. We elaborate on the implementation of these techniques and their advantages to systems development, problems we encountered while developing Snowball, and  we briefly discuss our observations while using Snowball to develop a large Internet-based object-oriented database system.

MUTANT: a MultiAgent Toolkit for Artificial Life Simulation
S. Calderoni and P. Marcenac, IREMIA, Reunion's island University, France

Nowadays, many artificial life research areas resort to agent-based simulation. This fact has brought us to design a powerful generic platform that would allow scientists in those fields of research to easily build simulation environment.  This platform, called MUTANT, includes a model of self-adaptive agent, with genetic evolving capabilities as learning mechanisms. The platform also includes a powerful graphical user interface providing many tools for both modeling and simulation. There are tools for agent¹s design, behavior¹s programming, environment¹s description, and observation of running simulations. MUTANT is being developed in Java with the aim of being directly usable throughout the Internet.

GEAMAS v2.0: An Object-Oriented Platform for Complex Systems Simulations
JC. Soulie, P. Marcenac, S. Calderoni, and R. Courdier, IREMIA, Reunion's island University, France

This paper presents the object oriented design and implementation of GEAMAS V2.0, a toolkit for virtual simulations of complex systems. GEAMAS V2.0 is structured in three modules:  the Kernel, the Generation Environment and the Simulation Environment. The Kernel implements an object model for agents and provides generic classes. The Generation Environment allows the graphical design of applications. The Simulation Environment enables the observation of the simulation¹s evolution via Graphical User Interface tools. The implementation uses Java 1.1. We applied GEAMAS V2.0 to the sand-pile automaton problem. This reference application, which is easily modeled with GEAMAS V2.0, provides a first validation of our system architecture and simulation mechanism.

An Architecture for Unified Dialogue in Distributed Object Systems
A. Larsen and P.D. Holmes, Norwegian Computing Center (NR), Norway

In traditional information systems, the user interface is controlled by one single application. In distributed systems, several distributed components may want to influence the appearance and logic of the user interface. This paper describes a Unified Dialogue Architecture which enables several distributed components to control the logic and contents of the user dialogue while keeping the dialogue consistent.

This architecture is a practical example of using dialogue agents, CORBA and Java. Details are described in connection with a large domain-specific distributed system called SPACE. Discussion is also provided as to other manners in which this architecture may be implemented, followed by a discussion concerning other problem areas in which the Unified Dialogue Architecture can be effectively applied.

AutoPilot: Experiences Implementing a Distributed Data-Driven Architecture
S.S. Foster, B.A. Nebesh, Department of Defense, USA, and Dana Moore, AT&T Laboratories, USA

Self-directed mobile software agents are a comparatively recent architectural design pattern. Mobile software agents, coupled with two other design patterns, Place and Trader, can be used to construct processing architectures which are scalable, flexible, and extensible. Certain routing workflow problems (text processing and dissemination, claims processing) in which the potential processing paths through a routing domain are initially indeterminate seem especially well suited to an Agent-Place-Trader design architecture. This paper motivates the architecture with a description of challenges presented by the functional requirements of a text processing and dissemination system. The paper continues with a description of our prototype's design, implementation, and object-oriented tools used. An analysis of the benefits and limitations of using various agent systems in conjunction with the C++ and Java programming languages will be presented. The authors draw conclusions regarding architectures for dynamic distributed processing in general, and workflow problems in particular.

Data Access & Transportation Service for the CORBA Environment
C.H. Ball and S. Hope, University of Wales, Bangor, UK

CORBA is an ideal environment in which to build component applications. However, the number of services available to support these component applications are lacking in certain areas of CORBA. This paper presents an overview of two services based in the CORBA environment. The Data Object Service provides a generic framework of interfaces to provide access to data in various heterogeneous datastores. The paper also discusses the similarities and differences between Data Object Service and the OMG Persistent Object Service. The other service is the Stream Tunnel Service. The Stream Tunnel Service allows distributed streams to be set-up. CORBA objects implementing the Streamable interface of the OMG CosExternalization Service can be pushed and pulled through these streams. The streams can be implemented using different network data transport mechanisms. The paper describes an investigation into two data transport mechanisms - ORB based and socket based.

Tool Support for Design by Contract
R. Ploesch, Johannes Kepler University Linz & C. Doppler Laboratory for Software Engineering, Austria

Numerous experience reports indicate that prototyping is a serious and successful development strategy. We believe that it is not sufficient to provide graphical notations for object-oriented analysis, but that the notation of contracts in conjunction with prototyping, i.e., building executable models, is the proper technique for mastering complexity and gaining insights into a problem domain. We therefore developed a set of tools that is especially suitable for functional prototyping and for architectural prototyping.

The underlying prototyping model is based on object-orientation and contracts, i.e., assertions. The infrastructure tools are implemented with the object-oriented programming language Python, while the high-level tools (assertion browser and graphically oriented debugger for assertions) are implemented in C++.

iContract ­ The Java Design by Contract Tool
R. Kramer, Cambridge Technology Partners, Switzerland

Until today, the explicit specification of "software contracts" by means of class invariants and method pre- and post-conditions was only available to Eiffel developers. iContract is the first tool that provides the same thorough support for Java.

iContract is a freely available source-code pre-processor that instruments sourcecode with checks for class invariants, pre- and post-conditions that may be associated with methods in classes and interfaces. Special comment tags (@pre, @post, @invariant) are interpreted by iContract and converted into assertion check code that is inserted into the source-code. iContract supports contract propagation via all 4 Java type extension mechanisms (class extension, innerclasses, interface implementation and interface extension).

Due to the non-mandatory nature of the comment tags, source code that contains design by contract annotations remains fully compatible with Java and can thus be processed with standard java compilers, enabling a risk-free adoption of the technique in your organisation.

Using IDLs to Support Path Expressions and Programming by Contract
D. Watkins, Monash University, Australia

This paper describes how Path Expressions and Programming by Contract can be supported in Interface Definition Languages (IDLs) without the need for any IDL extensions or new keywords. The Programming by Contract model described here contains extensions which allow clients to place constraints on method calls at runtime, to improve system reliability and performance. As no IDL extensions are used, this system can be incorporated into new and existing systems and improve the quality and reliability of distributed object oriented systems. An example of the specification and a demonstration of its use are also presented.

The Interaction of Access Control and Object-Orientation in Extensible Systems
W.C. Hsieh, University of Utah, USA; P. Pardyak, M.E. Fiuczynski, B.N. Bershad, University of Washington, USA; and C. Garrett, Equator Technologies Consulting, USA

In this paper we describe how object-oriented language design interacts with access control in extensible systems, based on our experience in building \spin, an extensible operating system. Several modern extensible systems, such as Java-enabled web browsers and \spin, use object-oriented languages for extensibility. These systems allow extension programs written in their languages (Java and Modula-3, respectively) to be linked in at run time. This paper makes two primary contributions.  First, it presents a case study of the issues that arise in access control and classes: it describes how access control over classes is affected by various language design choices. Second, it compares the access control mechanisms we chose in \spin, which are mostly link-time, with those in Java, which are mostly compile-time.

Weak Subtyping
W. Löwe, R. Neumann, M. Trapp, and W. Zimmermann, University of Karlsruhe, Germany

Object-oriented technology promises effective construction of reliable software by reusing flexible components. Generally this flexibility is based on abstract classes and polymorphism. Developers can combine existing components with classes that conform to certain abstract classes. In most object-oriented languages conformance is expressed by inheritance - subclasses are assumed to conform to their superclasses and hence may substitute them. Specialized subclasses, which are often essential, may not conform to their superclasses. Polymorphic use of these classes may lead to runtime exceptions.

This work introduces the concept of weak conformance, which provides a more flexible notion of substitutability with respect to a given application context. It demonstrates how this concept can be integrated into any object-oriented programming language. Furthermore it presents an algorithm, which detects critical polymorphic method calls, i.e. calls that might cause problems in some context.

Finally the paper discusses alternatives in handling such calls. This in summary, enables enhanced reuse even of specialized classes.

Reasoning About Polymorphic Behavior
N. Soundarajan and S. Fridella, Ohio State University, USA

Polymorphism is one of the most important ideas underlying the Object-Oriented approach. Polymorphism allows us to use an object that is an instance of a derived class in place of an object of the base class, with the run-time dispatch ensuring that the methods applied are the ones defined in the derived class. Thus client code can deal with objects that may be instances of any of the derived classes of a given base class, but treat them uniformly as if they were all instances of the base class. In this manner, the client programmer is able to exploit the richer behavior provided by the derived class. This paper presents a technique that this programmer can use when reasoning about the behavior of the polymorphic code, in particular the enriched behavior that results from using the derived class methods, and applies the technique to some simple examples.

Refer to the Conference Schedule for more scheduling information