Chair: Peter F. Sweeney,
IBM T. J. Watson Research Center

Posters provide an excellent forum for authors and conference attendees to discuss the authors' work. Authors may choose the poster format because their work is conveyed particularly well via this highly visual medium, their work may be too preliminary for a full paper, or they would like more interaction with their peers. Posters cover the same interest areas as the Technical Papers and Practitioner Reports.

The OOPSLA 2000 Posters program begins with a special session at the Welcome Reception on Monday night where all posters will be on display with the authors present to meet with attendees and discuss their work. This setting is informal and conducive for conversation. For the rest of the Conference, posters will be displayed in the Exhibit Hall.

The Posters Committee appears in the OOPSLA 2000 Committtees section of the Program.

1. The Camp Smalltalk ANSI Test Suite
Ralph Johnson, University of Illinois at Urbana-Champaign
Donald MacQueen,
JWARS
A test suite for the Smalltalk ANSI standard has been developed using SUnit. It consists of several thousand tests, has a way of reusing protocol-based tests for different concrete classes that are being tested, and was developed as an open-source project at Camp Smalltalk (http://camp.smalltalk.org).

2. Evaluation of Coupling in the Context of Java Interfaces
Mohsen D. Ghassemi and Ronald R. Mourant, Northeastern University
The coupling factor metric offered by unified framework measures the complexity of object-oriented software systems. This metric is evaluated in the context of Java interfaces. Interactions are identified, the effectiveness of the model is discussed, and an extension of the model is offered for more accurate measurement of complexity.

3. Global Reuse Strategy Based on Use Cases
Michal Smialek, Warsaw University of Technology and InfoVIDE Ltd.
This poster introduces two concepts based on use cases: business patterns and automation patterns. It describes a connection between the business and automation patterns with classes. Finally, it presents an idea of multi-level library that allows global reuse of software development models and code.

4. Scenario-Based Reengineering
Prasad Palacharla and Lizette Velazquez, Lucent Technologies
Using the Use Case Behavior Engineering Tool (UBET), one can specify system requirements as scenarios and generate system designs from it. Currently UBET cannot analyze an existing system design and generate system functionality from it. Adding this capability will allow users to reengineer, remodel, redesign, and synchronize existing system design and functionality together.

5. A Workbench for Quality Based Software Re-engineering
Ladan Tahvildari and Kostas Kontogiannis, University of Waterloo, Canada
We claim that re-engineering legacy systems requires a comprehensive framework to guide the process. Our framework focuses on, at the architectural level, re-engineering the original architecture to conform with an "intended design," and at the source code level, re-engineering a procedural language into an object-oriented one. A case study is presented as a proof of concept.

6. Design Patterns and Real-time Object-Oriented Modeling
Ross McKegney, Queen's University, Canada
Terry Shepard, Royal Military College of Canada
Real-time object-oriented modeling tools (e.g., Rational Rose-RT, i-Logix Rhapsody) allow developers to focus on software architecture by abstracting away low-level implementation details. We believe that design patterns can be very beneficial in this context, and present the rationale and concepts behind a proposal for the extension of a toolset to support them explicitly.

7. Reinvent the Wheel
Lawrence Carleton
We choose Design Patterns under conditions of bounded rationality. We assess a list of candidates against a requirements set, modifying both. We choose the first pattern satisfying the requirements. Satisfying usually works. But not always. When should we decide against this approach and attempt an original solution? I offer a pattern.

8. From Documents to Applications via Frameworks: The Tools and Materials Approach
Martin Lippert, Stefan Roock, and Heinz Züllighoven, University of Hamburg & APCON Workplace Solutions GmbH
The Tools and Materials approach guides the software developer through the whole object-oriented development process. It provides a number of document types, several design metaphors for conceptual modeling, and related technical design patterns. A Java-based application framework (called JWAM) tailored for this approach completes the support for application development.

9. Aspect-Oriented Frameworks: The Design of Adaptable Operating Systems
Paniti Netinant, Constantinos A. Constantinides, and Tzilla Elrad, Illinois Institute of Technology
Mohamed E. Fayad, University of Nebraska at Lincoln
Operating systems are dominated by many aspects and complex interactions. Supporting separation of concerns and aspectual decomposition in the design of operating systems, using Aspect-Oriented Frameworks, provide a number of benefits such as comprehension, reusability, adaptability, and reconfigurability. Aspect-Oriented Framework is a three-dimensional model consisting of components, aspects, and layers.

10. Towards a Two-Dimensional Separation of Concerns
Constantinos A. Constantinides and Tzilla Elrad, Illinois Institute of Technology
Our work concentrates on the aspectual decomposition of concurrent object-oriented systems. We have built an aspect-oriented framework where functional components and aspects are designed relatively separately from each other. This separation allows for reusability and adaptability. Our goal is to achieve an improved separation of concerns in both design and implementation.

11. iFlow: A Data Streaming Application Framework Based On a Uniform Abstraction
Andrew K. Lui, Mark W. Grigg, Michael J. Owen, and T. Andrew Au,
Department Science and Technology Organisation, Australia
This poster presents a stream based programming framework called iFlow. iFlow is based on a uniform set of easy-to-use application components that provide a high-level abstraction of data streams. We illustrate the basic capability of iFlow applied to an on-demand imagery dissemination application, resulting in an efficient and flexible system.

12. Taking advantage of Design Patterns in GIS domain
L. Polasek, A. Zambrano, S. Gordillo, J. Bazzocco, G. Trilla, D. Cano, and
A. Lliteras,
LIFIA-Facultad de Informática, UNLP
It is hard to adapt traditional Geographic Information System (GIS) applications to new requirements, like new reference systems, integration of vector and raster models, or handling continuous information. This poster presents an object-oriented architecture, based on design patterns, for building GIS applications that addresses the issues of flexibility, adaptability, and reuse.

13. Adaptations to OCL for Ensuring Quality of Geographic Data
Maja D'Hondt, Thomas Wallet and Miro Casanova, Vrije Universiteit Brussels
In the Geographic data domain, it is necessary to release data with the highest degree of quality. We use UML to represent the conceptual model of geographic data, and OCL to express constraints for ensuring its quality. We present some adaptations to OCL in order to make it applicable to this domain.

14. Constrained Objects for Modeling Complex Structures
Pallavi Tambay and Bharat Jayaraman, University at Buffalo (SUNY)
Constrained objects are objects whose state is regulated by constraints. They are applicable in many domains, e.g., engineering and organizational modeling. Our proposed language (Cob) supports class hierarchies, constraints, and preferences; and our computational model supports constraint satisfaction, optimization, and relaxation. Constrained objects are thus a declarative approach to object-oriented programming.

15. Component Visualization Based on the Programmer's Conceptual Models
Ludger Martin and Elke Siemon, Darmstadt University of Technology
Current programming environments for user interface development provide visual programming techniques to aid in using object-oriented and component technology concepts. We suggest a clear separation of visualizations for component assembly on the one hand and object-oriented programming on the other hand, and present metaphors and a programming environment.

16. ContextBox: A Visual Builder for Context Beans
David H. Lorenz, Northeastern University
We present an assembly-design environment that supports the new JavaBeans extensible runtime containment and services protocol. The environment provides: a vehicle for demonstrating the Java 2 component model; a third-party client for testing BeanContext and BeanContextChild components; and a prototype illustrating how a visual builder might unify visual and context nesting during component assembly.

17. Verdantium: Towards A Java-Enabled Compound Document Model
Thornton Green, Arizona State University
Java Beans provides a robust mechanism for combining software components. However, Java Beans components
are usually not being combined to create documents in a word processor, illustration program, etc. Verdantium is a Java-based API for document embedding that defines software components using a novel variant of Model-View-Controller (MVC).

18. Component Migration with Enterprise JavaBeans
Michael Richmond, Information and Communication Sciences, Macquarie University, Australia
Location flexibility is important in component architectures. We classify this flexibility according to component bind time.
This classification introduces component migration as a way of divorcing runtime component locality from bind time locality. Finally, we identify a number of open issues that our current work on Enterprise JavaBean migration will address.

19. Adaptive Object-Model Architectures
Joseph Yoder, The Refactory, Inc.
Reza Razavi, Université Pierre et Marie Curie
The unrelenting pace of change that confronts contemporary software developers compels them to make their applications more configurable, flexible, and adaptable. A possible way to meet such requirements is to use an Adaptive Object-Model. This poster describes common architectures for adaptive object-models and also summarizes the results from an ECOOP 2000 workshop.

20. An Architecture for the Evolution of Web Applications
Paulo Caroli and Carlos Jose Pereira de Lucena, PUC-Rio
Marcus Fontoura, IBM
This poster presents a software architecture that is especially useful for managing the evolution of Web applications. This work proposes a hybrid architecture which combines the n-tier, broker, and blackboard architectural patterns. We presents a large case study that illustrates how the architecture may be applied in practice.

21. R-RIO: Reflective-Reconfigurable Interconnectable Objects
Alexandre Sztajnberg, Instituto de Matemática e Estatística/UERJ
Orlando Loques, Instituto de Computação/UFF
R-RIO combines Meta-Level Programming and Software Architecture approaches, providing a useful framework to design and manage applications with separation of concerns. This framework includes a component / configuration model, an ADL, and a reflective middleware. The reflective middleware and companion tools have been implemented
and tested with distributed applications.

22. Optimization of Distributed Object-Oriented Systems
William Ray, Naval Postgraduate School
Distributed object-oriented systems consist of object servers and client applications on a network of computers. Optimal deployment strategies for object servers change given deviations in object servers, client applications, user interaction, and hardware modifications. This poster describes a methodology that infers optimal deployments from changes to these variables – such a methodology would aid developers of distributed object-oriented systems.

23. Transparent Fault Tolerance for CORBA based Distributed Components
Ronald de Man, Rudynell Millian, and Maarten Wegdam, Lucent Technologies, The Netherlands
Aniruddha Gokhale and Shalini Yajnik, Lucent Technologies, USA
The OMG Fault Tolerant CORBA standard (FT-CORBA) specifies application-transparent fault tolerance for CORBA 2.x objects. We extend FT-CORBA for the Distributed Software Component framework (DSC), which is a precursor to the CORBA Component Model (CORBA 3.0). We illustrate how we use our FT-CORBA extensions for a DSC-based, QoS-aware service provisioning platform.

24. Object-Oriented Design and Implementation of the Multi-Agent System AgentTeam
Bora I. Kumova, Dokuz Eyluel University
AgentTeam is a framework for agent-based flexible management of distributed relational data that is stored in heterogeneous databases. It consists of domain-dependent system concepts and partially domain-independent software design concepts. In this contribution, the domain-independent software design concepts are evaluated with respect to reuseability and scalability, and discussed in detail in the context of a prototype, CourseMan.

25. Wireless Architecture For Access to Remote Services (WiARS)
Amisha Thakkar and Bina Ramamurthy, State University of New York at Buffalo
Our research explores the potential of creating a remote access environment in which connection and interaction of varied devices and services could be as easy as plug-and-play. We combine the Wireless Application Protocol (WAP) and JINI technologies to enable this implementation.

26. Modeling XML Applications with UML
Dave Carlson, Ontogenics Corp.
The design of XML vocabularies (DTD or XML Schema) is generally separated from application design using UML. Large XML vocabularies are also difficult to understand and communicate with business users. This poster describes the use of UML class diagrams for modeling XML vocabularies and generating DTDs and Schemas from an XMI representation of the UML.

27. A Process Evaluation and Development Framework (PEDF)
Daniel A. Rawsthorne, ACCESS
The main reason software projects fail is that people don't know how to make them succeed. The PEDF allows you to understand your Process, and how to make it succeed. It forces you to take a hard look at what you're doing, and why you think it's supposed to work.

28. ooSEM: A Process Model for Object-Oriented Development in an Industrial Environment
Hermann Kaindl, Stefan Huber, Ömer Karacan, Ilir Kondo, Herwig Schreiner, and Helge-Wernhard Süß, Siemens AG Österreich
Applying current object-oriented (OO) methods is by itself not sufficient for a certification according to the EN ISO 9001 standard. This poster presents a process model for supporting OO development in an industrial environment that is consistent with this standard. Among other things, it deals with project management and control, comprehensive documentation, quality assurance, and configuration management.

29. Refactoring Tool Challenges in a Strongly Typed Language
Christopher Seguin, Independent Researcher
This poster considers the challenges associated with writing an automated refactoring tool for a strongly
typed language by comparing the push-up field refactoring in Smalltalk and Java. The Smalltalk refactoring removes the field from descendant classes. The Java transformation might involve casting the field into different types where it is accessed.

30. State Machine Specification Directly in Java and C++
Alexander Sakharov, GTE Laboratories
Specifications of state machine components and their assembly in applications as well as respective code generation facilities are introduced directly in Java and C++. The component specifications define states and transitions expanded by adding regular expressions of events. The assembly specifications define containment, data exchange, synchronization, and event sources.

31. JML: Notations and Tools Supporting Detailed Design in Java
Gary Leavens, Iowa State University
K. Rustan and M. Leino, Compaq Systems Research Center
Erik Poll, University of Nijmegen
Clyde Ruby, Iowa State University
Bart Jacobs, University of Nijmegen
JML is a notation for specifying the detailed design of Java classes and interfaces. JML's assertions are stated using a slight extension of Java's expression syntax. This should make it easy for programmers to learn. Tools for JML aid in static analysis, verification, and run-time debugging of Java code.

32. MixJuice: An Object-Oriented Language with Simple and Powerful Module Mechanism
Yuuji Ichisugi, PRESTO Japan Science and Technology Corporation
MixJuice is an object-oriented language based on Java. Its module mechanism is simpler and more powerful than that of Java. In this language, classes and modules are completely orthogonal. MixJuice uses the differences of class hierarchies as a unit of information-hiding and reuse.

33. Fantastic, Unique, UML Tool for the Java Environment (FUUT-je)
Ghica van Emde Boas, Bronstee.com Software & Services B.V.
The architecture of a UML and Java based prototyping tool is shown. FUUT-je is highly customizable through a building block approach and by generating it from a model of itself. It is very efficient for building code generators for complex programming environments such as IBM's San Francisco business framework.

34. Decompiling Java Bytecodes with Soot!
Jerome Miecznikowski and Etienne Gagnon, McGill University
We present a decompiler that converts Java class files back to Java source. Our work is based on the Soot framework and we concentrate on two essential algorithms: (1) Type inference for local variables, and (2) Control flow restructuring.

35. Soot - a Java Bytecode Optimization and Annotation Framework
Raja Vallee-Rai, Patrick Lam, Patrice Pominville, Feng Qian, and Laurie Hendren, McGill University
Soot is an optimization and annotation framework for Java bytecodes. The goal is to produce class files which execute faster on Java virtual machines as well to annotate the code with annotation or profiling information which is optionally useful to Java virtual machines.

36. Multi-Dispatch in the Java Virtual Machine: Design and Implementation
Christopher Dutchyn, Paul Lu, Duane Szafron, and Steve Bromling, University of Alberta, Canada
Wade Holst, University of Western Ontario, Canada
Mainstream single-dispatch object-oriented languages force programmers to apply explicit, slow, and error-prone double-dispatch techniques. We extend the JVM (without Java Language extensions) to support multiple-dispatch while maintaining source and binary compatibility, and maintaining single-dispatch performance. Benchmarks show that our system executes a single multi-dispatch faster than an equivalent double-dispatch.

37. Towards a Graphical Notation to Express the C++ Template Instantiation Process
Arturo Sanchez, University of North Florida, Jacksonville
Jia Dei-Wei, University of Massachusetts, Dartmouth
This poster introduces a graphical notation that can be used as an intermediate abstract medium on which the result of C++ template analysis can be expressed. We envision applying it to the development of compiler "plug-ins" to enhance C++ template error reporting, and template visualization, to name just a few applications.

38. Adding Parametric Polymorphism to the Common Object Request Broker Architecture (CORBA)
Wayne L. Bethea and Terrance Boult, Lehigh University
This poster showcases issues surrounding adding parametric polymorphism to CORBA. The merits of parametric polymorphism are widely published, yet there is no support for the parametric polymorphism paradigm in CORBA. This research should be of special interest to C++ programmers, and other genericity programmers, frustrated by the lack of this support.

39. The META4 Programming Language
Jason Kim, Lehigh University
Current object-oriented languages allow a programmer to add layers of abstraction in a structured and systematic manner, at the expense of limiting compiler optimizations. By restricting the language in a reasonable manner, as well as through additional in-language annotations, META4 allows the programmer to synergistically interact with the compiler to produce good code.

40. Kava - A Powerful and Portable Reflective Java
Ian S. Welch and Robert J. Stroud, University of Newcastle upon Tyne
Kava is a powerful and portable reflective Java that uses bytecode rewriting to implement behavioural reflection. In our poster we briefly overview the Kava system, give an example of its use, and contrast it with simple bytecode rewriting. More details about Kava are available from http://www.cs.ncl.ac.uk/research/dependability/reflection.

41. Quicksilver: A Quasi-Static Compiler for Java
Mauricio Serrano, Rajesh Bordawekar, Sam Midkiff, and Manish Gupta, IBM T. J. Watson Research Center
We present quasi-static compilation, a new approach that combines the benefits of static and dynamic compilation, for Java. The quasi-static compiler generates persistent code images ahead of time, and during a production run, adapts them to the new execution context while preserving global optimizations and maintaining binary compatibility.

42. Adaptive Optimization in the Jalapeño JVM
Matthew Arnold, IBM T. J. Watson Research Center and Rutgers University
David Grove, Stephen Fink, Michael Hind, and Peter F. Sweeney, IBM T. J. Watson Research Center
We present the architecture of the Adaptive Optimization System for the Jalapeño JVM. Our system is based on a federation of threads with asynchronous communication. We empirically demonstrate that sample-based profiling has low overhead and can improve startup and steady-state performance with and without the use of online feedback-directed inlining.

43. On the Predictability of Java Bytecodes
Karel Driesen, Patrick Lam, Jerome Miecznikowski, and Feng Qian, McGill University
Derek Rayside, University of Waterloo
How predictable are Java bytecodes? We measured how accurately the following can be predicted ahead of time (using simple prediction techniques employed in modern micro-architecture): 1) invoke targets, 2) load addresses, 3) new types. Prediction accuracy typically exceeds 95%, indicating optimization opportunities through recompilation after profiling or through adaptive micro-architecture.

44. Profile-Driven Pretenuring for Java
Stephen M. Blackburn, John Cavazos, Sharad K. Singhai, Asjad M. Khan, Kathryn S. McKinley and J. Eliot B. Moss, University of Massachusetts
Sara Smolensky, Mississippi State University
Pretenuring reduces copying in garbage collectors by placing long-lived objects in an uncollected region. We develop a new collector-neutral profiling approach to predict object lifetimes, and give collector-neutral pretenuring advice. Our simulations for Java programs show that pretenuring significantly reduces copying for generational and older-first collectors.

45. Action Guides for the Software Architect
Dana Bredemeyer and Ruth Malan, Bredemeyer Consulting
Bill Branson, Frank Russell Company
And the Action Guides Workshop Participants
We will present the results of the Action Guides Workshop. An Action Guide is targeted at a specific challenge the architect faces. A challenge may be technical (how to model the architecture; how to document an interface) or non-technical (how to create an architecture vision; what to communicate to whom).

46. Deploying Lightweight Processes
Pete McBreen, McBreen.Consulting
Jens Coldewey, Coldewey Consulting
Jutta Eckstein, Objects in Action
Christa Schwanninger, Siemens
This poster presents a summary of the workshop on Deploying Lightweight Processes. It highlights the ideas that were found to be useful across a range of processes and cultures. The poster also highlights the applicability of lightweight processes.

47. Ninth OOPSLA Workshop on Behavioral Semantics
Haim Kilov, Genesis Development Corporation, an Iona Technologies company
Ken Baclawski, Northeastern University
This poster presents the results of the OOPSLA 2000 Workshop on Behavioral
Semantics. The purpose of this workshop - in the tradition of our previous eight ones - is to bring together theoreticians and practitioners who write and use elegant business, system, and technology specifications, i.e., make semantics precise, clear and explicit. Workshop contributions range from research to industrial "war stories," with an emphasis on new areas like e-commerce.

48. Introducing Patterns (or Any New Idea) into Organizations
Mary Lynn Manns, University of North Carolina at Asheville
Linda Rising
Alan O'Callaghan, De Montfort University
The problems and solutions in introducing patterns, or any new idea, into an organization are being captured in a pattern language. This poster will provide a summary of these patterns, the outcome of the OOPSLA 2000 workshop on this topic, and an opportunity for others to contribute to this project.

49. Active Learning for Object-Oriented Design
Robert Biddle, Victoria University of Wellington
Rick Mercer, University of Arizona
Eugene Wallingford, University of Northern Iowa
This poster reports on the Active Learning for Object-Oriented Design workshop. Many people are introduced to object-oriented (OO) concepts, but only learn the words. This workshop will explore "active learning" techniques for OO design, where innovative teaching strategies are used to allow learners to be actively engaged in design work from an early point. Our focus is on design mentoring and innovative active strategies.

50. The Pedagogical Patterns Project
Helen Sharp, Centre for HCI Design
Mary Lynn Manns, University of North Carolina
Jutta Eckstein, Objects in Action
This project, which started in 1996, aims to encourage the capture and dissemination of successful experience of learning and teaching OT from industry and academia. Today, a significant body of material exists. We welcome contributions from people with experiences to share, or whose own practice is reflected in existing material.

51. Object Principles: Back to Basics
John Daniels, Syntropy Ltd.
Jutta Eckstein, Objects in Action
We present the results from an OOPSLA 2000 Educators' Symposium session: As OT becomes increasingly submerged beneath delivery technologies (like components), it's ever more important that educators are clear about the object principles that provide the benefits we claim. Will we be able to recognize the important principles in the diverse technologies?

52. Synchronous Active Objects
Claude Petitpierre, EPFL - Swiss Federal Institute of Technology
Java provides the means to handle multiple threads of execution as well as low level inter-thread communication primitives, which can be used to implement a user's concurrency paradigm. The paradigm presented in our poster, driven from the concepts of actor and rendezvous, is simple, yet powerful, and is compatible with the best known formal methods aimed at the analysis of concurrent systems.

53. An Understandability Metrics for Object Oriented Programs
Naoko Yamasaki, Ariake National College of Technology, Japan
Tetsuro Kakeshita, Saga University, Japan
We propose a software metric to evaluate understandability of OOPs. This metric is composed of a cost formula for understanding based on cognitive science and a model of the understanding process. Unlike Chidamber's metrics, our metric considers instances as well as classes. We have also evaluated understandability of structured programs using this metric.


Back to Final Program

 OOPSLA'98 Home