Technical Program

Quality

Session1

 Monday, August 2
 9:30 - 11:00

Performance Tuning Mobile Agent Workflow Applications
M.J. Flester, RABA Technologies, USA; S.S. Foster, Dept. of Defense, USA; D. Moore, AT&T Laboratories, USA; and B.A. Nebesh, Dept. of Defense, USA

Workflow systems based on mobile software agents improve overall flexibility and adaptability. The design of such systems does however, require that some attention be paid to performance tuning. This paper describes a decentralized agent control and management strategy that prevents system flooding and maintains good overall system throughput. Control of the system is divided among the following three controlling entities: the Workflow Service Broker (WSB), Agent, and Agent Pool. The WSB maintains information about what services are available on the network. The Agent maintains its itinerary, current state, and travel log; this information is used in conjunction with the information from the WSB to direct routing of the Agent. The Agent Pool maintains information about the number of agents in the system, and the overall system load. We discuss the implementation of this control strategy in a workflow application called Autopilot, which is a heterogeneous text processing workflow system where the elements are of unknown complexity and size, and where the potential processing paths through the routing domain are initially unknown. We discuss performance tuning aspects of the system and offer conclusions on such issues as agent pooling, payload simplification, object reference vs. object movement, and service co-location

Databases

Session2

 Monday, August 2
 11:30 - 13:00

Implementing a Distributed Garbage Collector for OO Databases
Richard Bielak & Jean-Pierre Sarkis, CAL FP Bank, USA

Persistent Object Synchronization with Active Relational Databases
F. Porto, S. Carvalho, R. Melo, PUC-Rio, Brazil; and M. Silva, MJVS Informatica, Brazil

One of the most common client/server architectures in enterprise systems today is the combination of object-oriented applications with active relational database systems. With this combination, developers have to overcome a difficult problem: the impedance mismatch between object orientation and the relational model.

To date, there are several incomplete approaches for describing the integration of static and dynamic object aspects and active relational databases. An important issue missing from these approaches is the state synchronization between server tuples and client-cached objects.

In a previous paper we proposed a technique for mapping the dynamic behavior of objects into active relational databases, using database triggers and stored-procedures. This paper extends our previous one with an architecture based on a replication strategy that mantains server tuples and client-cached objects synchronized with respect to state. This architecture automatically updates client-cached object versions when their corresponding server database tuples are updated.

Overview of the ROL2 Deductive Object-Oriented Database System
M. Liu, University of Regina, Canada

This paper presents an overview of ROL2, a novel deductive object-oriented database system developed at the University of Regina. ROL2 supports in a rule-based framework nearly all important object-oriented features such as object identity, complex objects, typing, information hiding, rule-based methods, encapsulation of such methods, overloading, late binding, polymorphism, class hierarchies, multiple structural and behavioral inheritance with overriding, blocking, and conflict handling. It is so far the only deductive system that supports all these features in a pure rule-based framework.

Testing

Session3

 Monday, August 2
 15:30 - 17:30

Measuring the Effectiveness of Method Test Sequences Derived from Sequencing Constraints
F.J. Daniels, Bell Laboratories, USA; and K.C. Tai, North Carolina State University, USA

Intra-class testing refers to the testing of the interaction among methods and data structures encapsulated within a single class. Our approach to intra-class testing is to execute sequences of instance methods that are derived from sequencing constraints and evaluate their results for correctness. These constraints impose restrictions on method behaviors and can be derived from a formal or informal specification of a class. This paper presents an empirical evaluation of different method sequence generation approaches, and of their effectiveness in detecting software faults. In addition, we define a number of coverage criteria based on method sequencing constraints for a class and examine the differences between them. C++ code, mutation and sequencing tools are used to perform evaluations.

A New Metrics Set for Evaluating Testing Efforts for Object-Oriented Programs
K. Periyasamy & X. Liu, University of Manitoba, Canada

Software metrics proposed and used for procedural paradigm have been found inadequate for object-oriented software products, mainly because of the distinguishing features of the object-oriented paradigm such as inheritance and polymorphism. Several object-oriented software metrics have been described in the literature. These metrics are goal-driven in the sense that they are targeted towards specific software qualities. In this paper, we propose a new set of metrics for object-oriented programs; this set is targeted towards estimating the testing efforts for these programs. The definitions of these metrics are based on the concepts of object-orientation and hence are independent of the object-oriented programming languages. The new metrics set has been critically compared with three other metrics sets published in the literature.

Benchmark Metrics for Enterprise Object Request Brokers
M. Vilicich & S. Aslam-Mir, Expersoft Corporation, USA

The growing interest in using Common Object Request Broker Architecture (CORBA) to distribute application objects over heterogeneous environments has led to an explosive growth in the number of Fortune-500 companies deploying major, mission-critical applications using such client/server (c/s) architectures. An overview of testing CORBA object request brokers will be given, including review of the potential issues involved in large-scale deployments of CORBA technology, discussion of appropriate empirical assessments, and guidance on appropriate measures of the ORB’s performance envelope. Metrics for enterprise level CORBA deployments are discussed including performance, scalability, reliability, and interoperability. All concepts are discussed with the insight gain from an ORB vendor experienced with multiple transitions from the project development phase to the enterprise level production deployment. Developers and technical managers alike will benefit from the review of the current research in this area.

Analysis Techniques for Testing Polymorphic Relationships
R. Alexander, Software Productivity Consortium, USA; and J. Offutt, George Mason University, USA

As we move from developing procedure-oriented to object-oriented programs, the complexity traditionally found in functions and procedures is moving to the connections among components. More faults occur as components are integrated to form higher level aggregates of behavior and state. Consequently, we need to place more effort on testing the connections among components. Although object-oriented technology provides abstraction mechanisms to build components to integrate, it also adds new compositional relations that can contain faults, which must be found during integration testing. This paper describes new techniques for analyzing and testing the polymorphic relationships that occur in object-oriented software. The application of these techniques can result in an increased ability to find faults and overall higher quality software.

Java1

Session4

 Tuesday, August 3
 9:30 - 11:00

When to Trust Mobile Objects? Access Control in the Jini™ Software System
Charles Crichton, Jim Davies, and Jim Woodcock, Oxford University, UK

Detecting Evolution Incompatibilities by Analyzing Java Binaries
M. Mezini, University of Siegen, Germany; J.U. Pipka, University of Siegen & Daedalos Consulting, Germany; T. Dittmar, and W. Boot, Daedalos Consulting, Germany

The evolution of classes in a reusable object-oriented component, that is their appearance in new releases, may break independently developed subclasses. Especially, because of the use of implementation inheritance, even changes in the base class that do not modify the class interface may cause previously existing inheritor code to malfunction. This incompatibilities are of 'semantical' nature in the sense that their presence may not, in general, be detected by compilers or even the Java byte code verifier. In a world of interacting components from different developers it is extremely important that such incompatibilities get detected when inheritor code is integrated with the new version of the base component.

In this paper, we present a Java framework for incompatibility detection by analyzing Java binaries at component reintegration time. The fact that analysis is performed on binaries is of paramount importance, since assuming source code availability is not realistic. The framework can be thought of as a tool that complements the work of the Java loader and verifier providing a first step towards true evolution management in Java. The framework has an open design that allows other applications such as debuggers and/or binary component adaptation tools to be plugged in.

Specifying Java Frameworks Using Abstract Programs
A. Mikhajlova, Turku Centre for Computer Science & Åbo Akademi University, Finland

Documenting object-oriented frameworks poses a serious problem - informal descriptions are imprecise and ambiguous, whereas providing code as a part of documentation leads to over-specification, rendering future upgrades impossible. Precise specifications in the form of abstract programs succinctly and unambiguously expressing the functionality of framework classes can solve the problems with framework documentation. The key feature of such abstract programs is that they combine executable statements of a programming language, e.g. method invocations, with possibly nondeterministic specification constructs, which permit abstracting away from implementation details. In this paper we present a specification method based on uniform treatment of specifications and implementations. The method is based on a language JINSLA - Java INterface Specification LAnguage - which combines standard statements of the Java language with specification constructs. A specification of the intended behavior given in this language can serve as a precise documentation for users of the framework and its extension developers. To illustrate the applicability of our method to specification of object-oriented frameworks, we demonstrate how one can specify the Java Collections Framework which is a part of the standard Java Development Kit 2.0.

Frameworks1

Session5

 Tuesday, August 3
 11:30 - 13:00

Component Frameworks – A Case Study
H. Praehofer, J. Sametinger, and A. Stritzinger, Johannes Kepler University, Linz, Austria

The paper reports on an effort to use both the system theoretic discrete event simulation modeling formalism DEVS and the JavaBeans component model as a basis for a component-based discrete event simulation framework. The result of the synergism of DEVS and JavaBeans is a powerful component-based simulation framework together with a set of flexible bean components for building simulation systems.

Component frameworks are dedicated and focused architectures with a set of policies for mechanisms at the component level. In the paper we describe the component framework we have developed for discrete event simulations. Simulation components are based on this framework and can be composed for the creation of various simulation scenarios.

Answerer: A Design Pattern for Dynamical Conditional Execution
M. Omori, N. Ikeda, and J.-i. Yamamoto, Toshiba Corporation, Japan

In this paper, we propose a new design pattern named Answerer whose purpose is to eliminate the effort of recompiling a program due to changes of run-time environments. Most programs have to behave differently to accommodate with various run-time environments. As usual, the behaviors of such programs have to be specified in conditional blocks. When the run-time environment of a program changes, these blocks need to be modified and recompiled.

The Answerer pattern applies a reflection technique to take care of conditional execution. The reflection is an idea to provide programs with a mechanism for changing structure and behavior dynamically. Based on this idea, the Answerer pattern provides:
 (1) a model of conditional execution and specification rules,
 (2) a mechanism to structure a model dynamically from information acquired at run-time,
 (3) a mechanism to create and execute a conditional operation from a model created from (2).

Firstly, we found that it is necessary for structural items of (1) to implement the following information in order to implement the Answerer design pattern based on the above model and mechanisms:
 (a) an information about environmental factors that should be observed
 (b) an information about behavior that should be executed according to the factors

Secondly, we created the Answerer design pattern that implements (2) and (3).

In this paper, we explain how we applied and implemented the Answerer pattern with an example of Java applet of DVD authoring tool.

Enhancing an Event-Based OO Framework for Distributed Programming
B. Silverajan & J. Harju, Tampere Univeristy of Technology, Finland

This paper discusses an asynchronous event-based object-oriented framework, OVOPS, employing the usage of design patterns to incorporate and interwork with a CORBA enabled environment. Distributed programming is constantly evolving into a very realistic technology which enhances systems integration through interoperability, adaptability and flexibility. However such advantages, coupled with performance, can only be gained by the proper analysis and design of the systems or frameworks in question. The design methodologies presented in this work, including the usage of the design patterns and their modifications thereof, were also used to achieve the maximum portability possible for independence from underlying operating systems. Much of the techniques presented could have used alternatives such as synchronous multithreading mechanisms. However, threads often have high performance overheads and require a deep knowledge of synchronization patterns and principles in order to manage access to shared resources. Threading may also not be available on all platforms. Although this paper explores the interworking with CORBA systems, it also shows how, by using these design patterns, the interworking of OVOPS with other kinds of distributed object models can quickly and easily be incorporated, without being tied to one particular type of distributed technology such as CORBA.

Methods1

Session6

 Tuesday, August 3
 14:30 - 16:00

Use Case Pitfalls: Top 10 Problems from Real Projects Using Use Cases
S. Lilly, SRA International, Inc., USA

One of the beauties of use cases is their accessible, informal format. Use cases are easy to write, and the graphical notation is trivial. Because of their simplicity, use cases are not intimidating, even for teams that have little experience with formal requirements specification and management. However, the simplicity can be deceptive; writing good use cases takes some skill and practice.

Many groups writing use cases for the first time run into similar kinds of problems. This paper presents the author's "Top Ten" list of use case pitfalls and problems, based on observations from a number of real projects. These issues include undefined or inconsistent system boundary, use case model complexity, use case specification length and granularity, and use cases that are hard to understand or that are never complete.

The paper outlines the symptoms of the problems, and recommends pragmatic cures for each. Examples are provided to illustrate the problems and their solutions. A checklist for inspecting use cases is available from the author.

Use Case Modeling Guidelines
D.G. Firesmith, Lante, USA

This paper documents the decisions made, their rationale, and the lessons learned during the creation and use of a content and format standard for a software requirements specification (SRS). The software was for a large, complex, distributed embedded system. The analysis and specification of operational requirements was based on use case modeling, whereas the quality requirements and design constraints were specified using textual English.

Cooperative Software Development: Concepts, Model and Tools
J. Altmann & G. Pomberger, Johannes Kepler University Linz, Austria

The development of large software systems demands intensive cooperation amongmultiple project team members with different responsibilities. The development process is often distributed across time and space and takes place within and between specialized workgroups. This necessitates finding appropriate answers to questions related to division of labor, to communication, and to coordination and cooperation in the planning, development and maintenance of software systems.

Development environments that explicitly support group work are an important prerequisite for the production of high-quality software systems. Most of the software development environments in use today support primarily technical aspects and have shortcomings in the area of organizational support. This paper describes a model for cooperative work processes in software projects and a corresponding development environment that provides balanced support for both organizational and technical aspects of software development.

The work toward the conception of the model and the implementation of the development environment have been completed, and the evaluation of the proposed approach has begun. Experience to date with using the developed environment confirms the assumption that the cooperative, cluster-oriented development improves both productivity and quality. The presented approach excels primarily in its easily understandable model, the intuitive usability of the tools and the comprehensible presentation of process- and product-related information.

Frameworks2

Session7

 Wednesday, August 4
 9:30 - 11:00

View Programming for Decentralized Development of OO Programs
Hafedh Mili, Joumana Dargham, Omar Cherkaoui, Robert Godin, University of Québec in Montréal, Canada, and Ali Mili, Institute for Software Research, USA

There has been a lot of interest recently in the problem of building object-oriented applications by somehow combining other application fragments that provide their own overlapping definitions or expectations of the same domain objects. We propose an approach based on the split objects model of prototype languages whereby an application object is represented by a varying set of instances-- called views-- that implement different parts of its domain behavior but that delegate its core functionalities to a core instance: an object's response to a message depends on the views currently attached to its core instance. Our approach is not purely prototype-based in the sense that core instances and views are members of classes. Further, we recognize that the behavior inherent in views (classes) is often an adaptation of a generic behavior to the domain object at hand, and define VIEW POINTS as parameterized class-like algebraic structures to embody such a generic behavior. In this paper, we first describe view programming from the perspective of the developer. Next, we sketch a semi-formal model of view programming, and describe the steps needed to implement it in a class-based statically typed language, for instance, C++. Third, we look at the challenges and opportunities provided by view programming to support safe, robust, and efficient distributed applications.

Methods2

Session8

 Wednesday, August 4
 11:30 - 13:00

Contracts: From Analysis to C++ Implementation
R. Plösch & J. Pichler, Johannes Kepler University of Linz, Austria

Standard C++ does not provide mechanisms for working with assertions in the spirit of design by contract as proposed by Meyer. We earlier developed a set of techniques and tools, facilitating the prototyping of object-oriented architectures based on the ideas of design by contract. As it is crucial for us to support evolutionary prototyping we need to provide mechanisms to automatically transform the classes and assertions specified in our prototyping environment to C++. We therefore developed a system which automatically transforms classes and assertions of our prototyping system to C++. As a side effect our environment provides general mechanisms for realizing design by contract for the programming language C++.

A Comparison of Defensive Development and Design by Contract™
D.G. Firesmith, Lante, USA

Both Defensive Programming and Design by Contract are based on the use of assertions coupled with exceptions and are used for many of the same purposes. This paper provides a theoretical comparison of defensive programming vs. Design by Contract, documenting their similarities and differences. The paper emphasizes how they differ in their assignment of the responsibility for ensuring preconditions and the important ramifications of this difference. It concludes that Defensive Programming, when based on assertions, provides the benefits of Design by Contract while avoiding several of its drawbacks.

Interaction Graphs: A System for Specifying and Generating Object Interactions
Neeraj Sangal, Edward J. Farrell, and Karl J. Lieberherr, Tendril Software, USA

Teaching

Session9

 Wednesday, August 4
 14:30 - 16:00

Recording and Analysing User Actions in a Smalltalk Programming Environment
M.D. Macgregor, P.G. Thomas, and M. Woodman, The Open University, England

AESOP (An Electronic Student Observatory Project) is a system for recording, replaying and analysing user actions in LearningWorks, a Smalltalk programming environment. The project aims (i) to inform educators how best to effect object technology transfer by improving their teaching, (ii) to provide an apparatus for identifying problems neophytes experience while learning to program and (iii) to provide empirical evidence for improving the design of the programming environment. Initially AESOP is being targeted on a large scale distance learning course, Computing: An Object-oriented Approach, which is enrolling 5,000 mature students per year. This paper describes the project and gives a flavour of the research questions of how neophytes learn programming concepts, in particular object concepts as exemplified by Smalltalk. The implementation of a selection of tools is described and sample data is also explained. Current project status is reviewed and many issues are raised concerning what sort of data to collect.

Separable UI Architectures in Teaching Object Technology
R. Griffiths, M. Woodman, S. Holland, H. Robinson, and M. Macgregor, The Open University, England

Visualizing O-O Testing in Virtual Communities - Distributed Teaching and Learning
S. Ramakrishnan, Monash University, Australia

The Internet has been recognised not only as a tool for communication in the 21st century but also as an environment for enabling changes in the paradigm of teaching and learning. This paper describes our research effort on the design and delivery of quality educational material on object-oriented (O-O) testing in an Internet environment. O-O software testing has the advantage of being easily visualizable in terms of state changes and data-flows. We have attempted to show the inner workings of the complex processes involved in O-O testing. The O-O testing case studies considered contain visual images, animation, and interactive lessons, to assist active participation by learners to result in better understanding and knowledge retention. The distributed teaching and learning approach discussed in this paper employs appropriate UML diagrams, makes the diagrams test ready by including details of constraints as part of state/event transitions, and provides interactive lessons for learning O-O software testing. Furthermore, this paper describes a development process in visualization and interactivity to achieve improved learning outcomes of O-O software testing in an Internet based environment - (see http://www.sd.monash.edu.au/~sitar/se_educ_proj).

Java2

Session10

 Thursday, August 5
 9:30 - 11:00

Storing Java Objects in any Database
R.K. Ege, Florida International University, USA

Typical Java applications involve access to a database system. Database systems store data according to their type system, even object-oriented databases generally have their own storage structures. It is therefore necessary to convert Java objects as they are stored in a database, and to re-convert them when they are read. Ideally, this should be done behind the scenes by a support package. Our paper presents an approach that automates the conversion process without involving pre- or post-processing of Java code: we use a reflection mechanism, where Java code is inspected at run-time and changed to include the convert and re-convert effort. The result is a flexible and transparent Java database access.

Using Java to add "Stored Procedures" to Databases
R.K. Ege, N. Rishe, J. Liu, V. Lebedev, Florida International University, USA

The paper describes our approach to adding "stored procedure" capability to a semantic database system using Java byte-codes and Java's ability to dynamically load and execute Java code. Several steps were necessary: first we added a Java application programmer interface to the database system; then we created a database schema to hold Java executable code; then we constructed a Java class loader to allow code to be loaded from the database; then we enabled the creation of Java objects and executed the Java code for them. Our approach is not specific to our semantic database system, rather it can serve as a recipe for adding "stored procedures" to any database system.

A Concurrent Object-Based Model and its Use for Coordinating Java Components
S. Majoul, C. Percebois, and J.-P. Bodeveix, IRIT, Université Paul Sabatier, France

We present a canonic model expressing the behavior of a system of communicating objects through multiset rewriting. Then, we discuss the integration of the so-defined model into the Java language. The choices and the restrictions made to implement the model as well as the architecture of the system are presented. Finally, we propose to use the prototype that we carried out as a coordination tool for communicating Java components. We focus on applications built around InfoBus, a standard package providing an event-based protocol for dynamic data-sharing between components. We show how our model can be used to coordinate Java events flowing on a software bus.

Tools

Session11

 Thursday, August 5
 11:30 - 13:00

Managing the Software Development by Using the Recursive Multi-Threaded (RMT) Tool
A. Concepcion, C-P. Lin, California State University, USA; and S. Simon, Environmental Systems Research Institute, USA

A number of software life-cycles for object-oriented software development (Fountain Model, Recursive/Parallel Model, McGregor and Sykes Model, and Chaos Model Life-Cycle) exist today. However, these life-cycles have little or no support for estimating and monitoring progress during the development of the software. The ability to measure progress during the development is significant because it allows both the managers and the developers to determine whether a project is on schedule or not.

This paper presents the Recursive Multi-Threaded (RMT) software life-cycle which supports the monitoring of progress during development, addresses the specific needs of the developing object-oriented software, and attempts to resolve deficiencies found in many existing software life-cycles. What makes RMT unique from existing software life-cycles is its use of a "thread" for partitioning and organizing software development activities. Threads support iteration and recursion, which are critical concepts for the development of the software.

To implement the concepts of the RMT software life-cycle model, we develop the RMT Tool which is Java-based. The Tool was used in an actual software development project in our software engineering course to test its functionalities.

Entity-Relationship Software Development Environment
Toshimi Minoura & Pornsiri Muenchaisri, Oregon State University, USA

MysterX: A Scheme Toolkit for Building Interactive Applications with COM
P. Steckler, Rice University, USA

MysterX is an object-oriented Scheme toolkit for building applications from off-the-shelf COM components. The toolkit uses type information obtained at run-time to check the types of arguments passed to COM methods, obviating the need for compiling interface descriptions. MysterX hosts COM components in windows which display Dynamic HTML, without using a separate browser. Scheme code can manipulate the HTML elements and their style properties in such windows to create interesting visual effects. Event handlers written in Scheme can be associated with HTML elements. By integrating component technology with Dynamic HTML, MysterX can be used to write complete GUI applications.

Theory

Session12

 Thursday, August 5
 14:30 - 16:00

Communication as a Means to Differentiate Objects, Components and Agents
D. Deugo, F. Oppacher, B. Ashfield, Carleton University, Canada; and M. Weiss, Mitel Corporation, Canada

Choosing the right abstractions is important for managing the complexity of your system. Three important abstractions used today are object, component and agent. Many similarities exist between these abstractions, but to make proper use of each, one should have a good understanding of their differences. Too often, we hear people discussing their agent-based systems when they have simply used the object abstraction. In this conceptual paper, we use communication as a means to differentiate the three abstractions. We describe communications patterns for each abstraction using an abbreviated pattern format, identifying the contexts, forces and solutions to different problems that present themselves for each abstraction. Our objective is to help developers identify the abstractions they are working with so they can make better use of them.

Bounding Component Behavior via Protocols
S. Visnovsky, Charles University, Czech Republic; F. Plasil, and M. Besta, Charles University & Academy of Sciences of the Czech Republic, Czech Republic

One of the most promising approaches to software development is building applications from reusable, potentially off-the-shelf software components. In order to achieve a reasonable level of composition safety, it is desirable to describe the functionality of components and check for correctness of the functionality during composition. The description of functionality should be precise enough to allow automatic checking of the correctness, but at the same time easy to comprehend for programmers and simple to write for designers.

In this paper, we enhance the SOFA Component Description Language with a description of the pattern of communication in a component. The communication pattern is expressed through behavior protocols employing a notation similar to regular expressions. To provide different views on a component, the behavior protocols can be used at three levels of abstraction within the component's description: interfaces, component frame (black-box view), component architecture (gray-box view). The key achievements of this paper include the definition of the protocol conformance relation. Using this relation, the designer can in most cases statically verify that the frame protocol adheres to requirements of the interface protocols, and that the architecture protocol adheres to the requirements of the frame and interface protocols.

Towards Efficient Support for Executing the Object Constraint Language
P. Collet & R. Rousseau, I3S-CNRS-UNSA, France

The Object Constraint Language (OCL) forms part of the UML notation as a language to complete graphical models by expressing precise constraints or assertions. As OCL is developed as a non-executable language, expressed properties cannot be embedded as executable assertions in the resulting implementations to provide correctness testing. Nonetheless a large part of OCL seems to be easily executable, but straightforward implementations would be inefficient and detrimental to the approach. This paper proposes a pragmatic solution for an OCL runtime support and determines the origins of potential inefficiency. The evaluation of assertions is streamlined according to their roles and the possibility of sampling quantified assertions. The triggering of assertions is driven by a changed-based system that simplifies large-scale use while ensuring that unstable parts undergo more controls.