title: Streamlining the Project Cycle With Object-Oriented Requirements

authors:
Richard Jordan
Ruth Smilan
Alex Wilkinson

abstract: We have succeeded in streamlining the product development cycle by incorporating object-oriented technology into the requirements definition phase. We have developed a general format, supporting tools and a methodology for describing requirements in an object-oriented fashion. We have validated our approach by incorporating it into the new object-oriented methods being applied to our current project and observing the benefits that resulted. We describe the problems with our earlier requirements specifications which make them unsuitable for developing good object-oriented systems and then explain our approach which eliminates these pitfalls.


venue: oopsla

title: Extensible File Systems (ELFS): An Object-Oriented Approach to High Performance File I/O

authors:
John F. Karpovich
Andrew S. Grimshaw
James C. French

abstract: Scientific applications often manipulate very large sets of persistent data. Over the past decade, advances in disk storage device performance have consistently been outpaced by advances in the performance of the rest of the computer system. As a result, many scientific applications have become I/O-bound, i.e. their run-times are dominated by the time spent performing I/O operations. Consequently, the performance of I/O operations has become critical for high performance in these applications. The ELFS approach is designed to address the issue of high performance I/O by treating files as typed objects. Typed file objects can exploit knowledge about the file structure and type of data. Typed file objects can selectively apply techniques such as prefetching, parallel asynchronous file access, and caching to improve performance. Also, by typing objects, the interface to the user can be improved in two ways. First, the interface can be made easier to use by presenting file operations in a more natural manner to the user. Second, the interface can allow the user to provide an “oracle” about access patterns, that can allow the file object to improve performance. By combining these concepts with the object-oriented paradigm, the goal of the ELFS methodology is to create flexible, extensible file classes that are easy to use while achieving high performance. In this paper we present the ELFS approach and our experiences with the design and implementation of two file classes: a two dimensional dense matrix file class and a multidimensional range searching file class.


title: Type-Theoretic Foundations for Concurrent Object-Oriented Programming

authors:
Naoki Kobayashi
Akinori Yonezawa

abstract: A number of attempts have been made to obtain type systems for object-oriented programming. The view that lies common is “object-oriented programming = λ-calculus + record.” Based on an analogous view “concurrent object-oriented programming = concurrent calculus + record,” we develop a static type system for concurrent object-oriented programming. We choose our own Higher-Order ACL as a basic concurrent calculus, and show that a concurrent object-oriented language can be easily encoded in the Higher-Order ACL extended with record operations. Since Higher-Order ACL has a strong type system with a polymorphic type inference mechanism, programs of the concurrent object-oriented language can be automatically type-checked by the encoding in Higher-Order ACL. Our approach can give clear accounts for complex mechanisms such as inheritance and method overriding within a simple framework.


title: Complex Associations: Abstractions in Object-Oriented Modeling

abstract: Objects model phenomena and a phenomenon is usually a component. Information characterizing a component is encapsulated and accessible only by its methods. The relations between components are modeled explicitly by means of associations or references. A relation is also a phenomenon and objects can model this type of phenomena too. Components are usually related conceptually in diverse and subtle ways: Some relations are implicitly given and some are local to other more basic relations. Such kinds of relations are important for understanding the organization and cooperation of objects and may be supported in object-oriented analysis, design, and programming: An implicit association describes a relation between an object and objects local to this enclosing object, and a complex association describes an explicit relation between local objects in different enclosing objects. Such associations are described by classes and the objects have the usual properties including methods and attributes.


title: Implementing Constraint Imperative Programming Languages: The Kaleidospace'93 Virtual Machine

authors:
Gus Lopez
Bjørn N. Freeman-Benson
Alan Borning

abstract: Constraint Imperative Programming (CIP) languages integrate declarative constraints with imperative state and destructive assignment, yielding a powerful new programming paradigm. However, CIP languages are difficult to implement efficiently due to complex interactions between the two donor paradigms. Neither the virtual machines for classical object-oriented languages, nor those for existing constraint languages, are suitable for implementing CIP languages, as each assumes a purely imperative or a purely declarative computation model. We have developed a new virtual machine for CIP languages, the K-machine, an imperative machine with an incremental constraint solver and a constraint-based, rather than value-based, data store. This virtual machine allows user-defined constraints to be defined using constraint constructor definitions which are the CIP analog to method definitions. Similar to methods, these constructors are able to reference variables indirectly through many levels of pointers. The K-machine maintains relations between objects in the presence of state change to these indirectly referenced objects. The K-machine is capable of supporting a wide variety of CIP languages, including our most recent: Kaleidoscope'93.


title: Combining Contracts and Exemplar-Based Programming for Class Hiding and Customization

authors:
Victor B. Lortz
Kang G. Shin

abstract: For performance reasons, client applications often need to influence the implementation strategies of libraries whose services they use. If an object-oriented library contains multiple service classes customized for different usage patterns, applications can influence service implementations by instantiating the customized classes that match their needs. However, with many similar service classes, it can be difficult for applications to determine which classes to instantiate. Choosing the wrong class can result in very subtle errors since a customized class might use optimizations that work only over a restricted domain. In this paper, we show how client-side software contracts and exemplar-based class factories can be used to construct customized server objects. By expressing priorities and requirements in contracts, clients can delegate service class selection to the library and thereby avoid implicit dependencies on the library implementation. We have used this approach in the implementation of a real-time database system.


title: Methodology Standards: Help or Hindrance?

authors:
David E. Monarchi
Grady Booch
Brian Henderson-Sellers
Ivar Jacobson
Stephen J. Mellor
James E. Rumbaugh
Rebecca Wirfs-Brock

abstract: article Free Access Share on Methodology standards: help or hindrance? Authors: Grady Booch Rational Software Corporation Rational Software CorporationView Profile , Brian Henderson-Sellers University of Technology, Sydney University of Technology, SydneyView Profile , Ivar Jacobson Objective Systems AB Objective Systems ABView Profile , Steve Mellor Project Technology, Inc. Project Technology, Inc.View Profile , James Rumbaugh GE GEView Profile , Rebecca Wirfs-Brock Digitalk DigitalkView Profile , Chairman: David Monarchi University of Colorado, Boulder University of Colorado, BoulderView Profile Authors Info & Claims ACM SIGPLAN NoticesVolume 29Issue 10Oct. 1994 pp 223–228https://doi.org/10.1145/191081.191115Online:01 October 1994Publication History 5citation0DownloadsMetricsTotal Citations5Total Downloads0Last 12 Months0Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF


title: Experience with Representing C++ Program Information in an Object-Oriented Database

abstract: Two major issues related to storing program information in an OODB are sharing and clustering. The former is important since it prevents the database from consuming excessive disk space, while the latter is crucial, since it keeps clients running without thrashing. In our database, objects are shared across multiple programs' translation units, and are clustered by combining three techniques, namely, birth-order, death-order, and sharing-oriented clusterings. An initial experiment shows that, for a medium-size application, the database consumes 3.5 times less disk space than in a conventional environment, and that the invocation of a client is almost instantaneous.


title: Precise Concrete Type Inference for Object-Oriented Languages

authors:
John Plevyak
Andrew A. Chien

abstract: Concrete type information is invaluable for program optimization. The determination of concrete types in object-oriented languages is a flow sensitive global data flow problem. It is made difficult by dynamic dispatch (virtual function invocation) and first class functions (and selectors)—the very program structures for whose optimization its results are most critical. Previous work has shown that constraint-based type inference systems can be used to safely approximate concrete types [15], but their use can be expensive and their results imprecise.


title: A Distributed Garbage Collector for Active Objects

abstract: This paper presents an algorithm that performs garbage collection in distributed systems of active objects (i.e., objects having their own threads of control). Our proposition extends the basic marking algorithm proposed by Kafura in [1] to a distributed environment. The proposed garbage collector is made up of a set of local garbage collectors, one per site, loosely coupled to a (logically centralized) global garbage collector that maintains a global snapshot of the system state relevant to garbage collection. The specific features of the proposed garbage collector are that local garbage collectors need not be synchronized with each other for detecting garbage objects, and that faulty sites and communication channels are tolerated. The paper describes the proposed garbage collector, together with its implementation and performance for a concurrent object-oriented language running on a local area network of workstations.


title: Semantic Locking in Object-Oriented Database Systems

authors:
Rodolfo F. Resende
Divyakant Agrawal
Amr El Abbadi

abstract: Object-oriented databases are being increasingly used to model non-standard applications that emphasize modularity, composition, and rapid prototyping. A semantic locking protocol is presented for transaction management for such object-oriented databases. In particular, the protocol incorporates the semantics of complex objects, nested executions and dynamic conflicts resulting from referentially shared objects.


title: ODE: A Self-Guided, Scenario-Based Learning Environment for Object-Oriented Design Principles

authors:
Scott P. Robertson
John M. Carroll
Robert L. Mack
Mary Beth Rosson
Sherman R. Alpert
Jürgen Koenemann-Belliveau

abstract: ODE: A SELF-GUIDED, SCENARIO-BASED LEARNING ENVIRONMENT FOR OBJECT-ORIENTED DESIGN PRINCIPLES Scott P. Robertson,* John M. Carroll,* Robert L. Mack, Mary Beth Rosson,* Sherman R. Alpert, Jurgen Koenemann-Belliveau” IBM Research T. J. Watson Research Center 30 Saw Mill River Road Hawthorne, NY 10532 Internet:


title: Development of an OO Infrastructure for Mainframe Database Applications

abstract: Large mainframe installations need and want to exploit the advantages of Object Technology (OT), but without totally abandoning their legacy environments. Implementing Object Orientation in such a COBOL/CICS/DB2 environment is a challenge: there is neither language support, nor development tools, nor execution infrastructure, nor testing utilities. Yet Object Orientation can be fully implemented, and a project can still meet rigorous performance requirements and tough delivery time scales. The key is to develop an infrastructure. This paper relates the lessons learned in designing and implementing such an OO infrastructure at British Telecom.


title: Genericity versus Inheritance Reconsidered: Self-Reference Using Generics

abstract: As shown by the work of Bertrand Meyer, it is possible to simulate genericity using inheritance, but not vice-versa. This is because genericity is a parameterization mechanism with no way to deal with the polymorphic typing introduced using inheritance. Nevertheless, if we focus on the use of inheritance as an implementation technique, its key feature is the dynamic binding of self-referential operation calls. This turns out to be basically a parameterization mechanism that can in fact be simulated using generics and static binding. And for some applications this approach may actually be of more than academic interest.


title: Smalltalk in the Business World: The Good, the Bad, and the Future (Panel)

authors:
Yen-Ping Shan
Ken Auer
Andrew J. Bear
Jim Adamczyk
Adele Goldberg
Tom Love
Dave A. Thomas


title: Prototype-Based Languages: Object Lessons from Class-Free Programming (Panel)

authors:
Randall B. Smith
Mark Lentczner
Walter R. Smith
Antero Taivalsaari
David M. Ungar


title: MI - An Object Oriented Environment for Integration of Scientific Applications

authors:
Andrea Spinelli
Paolo Salvaneschi
Mauro Cadei
Marino Rocca

abstract: Scientific and engineering software is often produced by integration of existing software components of the size of a whole program. However, on the average, scientific software was not developed for reusability and is quite distant from the user model of the application problem; integration and retrofitting is as such a costly process. An architecture, methodology and several C++ class libraries for supporting integration are introduced. The architecture separates a software component layer, and an integration layer. The latter in based on the concept of software model, that is an abstraction of components and a representation of the system differing from its actual physical structure. The methodology is based on matching needs with existing models. The C++ class libraries are explained in some detail. The application to two major systems is analysed and the ideas behind seven other systems are briefly outlined. Some lessons learned are summarised in the conclusions.


title: Virtual Images: Interactive Visualization of Distributed Object-Oriented Systems

authors:
Jean-Yves Vion-Dury
Miguel Santana

abstract: In spite of growing needs in many areas, there is a lack of powerful graphical interfaces for interacting with large and complex sets of objects. Debugging, management and monitoring tools for object-oriented distributed systems or databases, for instance, need new interfaces that allow high quality visualization and interaction.


title: Interfaces, Protocols, and the Semi-Automatic Construction of Software Adaptors

authors:
Daniel M. Yellin
Robert E. Strom

abstract: In this paper we show how to augment object-oriented application interfaces with enhanced specifications that include sequencing constraints called protocols. Protocols make explicit the relationship between messages (methods) supported by the application. These relationships are usually only given implicitly, either in the code or in textual comments. We define notions of interface compatibility based upon protocols and show how compatibility can be checked, discovering a class of errors that cannot be discovered via the type system alone. We then define software adaptors that can be used to bridge the difference between object-oriented applications that have functionally compatible but type incompatible interfaces. We discuss what it means for an adaptor to be well-formed. Leveraging the information provided by protocols, we show how adaptors can be automatically generated from a high-level description, called an interface mapping.


title: Type Feedback vs. Concrete Type Inference: A Comparison of Optimization Techniques for Object-Oriented Languages

authors:
Ole Agesen
Urs Hölzle

abstract: Two promising optimization techniques for object-oriented languages are type feedback (profile-based receiver class prediction) and concrete type inference (static analysis). We directly compare the two techniques, evaluating their effectiveness on a suite of 23 SELF programs while keeping other factors constant.Our results show that both systems inline over 95% of all sends and deliver similar overall performance with one exception: SELF's automatic coercion of machine integers to arbitrary-precision integers upon overflow confounds type inference and slows down arithmetic-intensive benchmarks.We discuss several other issues which, given the comparable run-time performance, may influence the choice between type feedback and type inference.


title: Extending the Statechart Formalism: Event Scheduling & Disposition

authors:
Arthur Allen
Dennis de Champeaux

abstract: Statecharts are extended to deal with events when no applicable transition is available, and to resolve conflicts relative to event scheduling and response that can arise whenever multiple states can be active simultaneously. Event closure and event scheduling are achieved without having to clutter up a basic statechart. The extensions are effected by means of declarative event disposition rules. These rules, together with the statechart topology, determine the contents of one or more disposition matrices. These matrices are combined with the statechart state to determine the response of the event dispatcher to incoming events. The operation of the event dispatcher is also described. A detailed example illustrates these concepts, which are further characterized, for the benefit of working programmers, in the form of a behavioral design pattern. A tool called StateCraft embodies these notions.


title: Evolving to Objects - The Witches' Brew

authors:
Don Baron
Tom Arnold

abstract: "Double, double toil and trouble, fire burn and cauldron bubble" … chant the witches of Macbeth. Take a corporation with a rich, decades-old history of providing on-line services on MVS mainframes, coupled with a vision of the future including OO design and programming, DCE for client-server infrastructure, heterogeneous platform mixes across the Unix and PC worlds, and plan to tie that back to the established systems - and you have a Witches' Brew of your own. The question for our project has been "How to introduce OO technology into an existing project framework with the least effort and most benefit?". Recent industry experience reports detailing the blending of OO and DCE indicate that this has not been easy; our experience confirms that, but our approach has allowed us to utilize the strengths of OO to minimize the complexities inherent in the mix.


title: A Metaobject Protocol for C++

abstract: This paper presents a metaobject protocol (MOP) for C . This MOP was designed to bring the power of meta-programming to C programmers. It avoids penalties on runtime performance by adopting a new meta-architecture in which the metaobjects control the compilation of programs instead of being active during program execution. This allows the MOP to be used to implement libraries of efficient, transparent language extensions. 1 Introduction A metaobject protocol (MOP) is an object-oriented interface for programmers to customize the behavior and implementation of programming languages and other system software. The usefulness of this kind of customizability has been argued elsewhere[11, 9, 10], and interesting MOPs have been included in languages such as Lisp[20], ABCL[21], and, to a lesser degree, Smalltalk[6]. The goal of our work is to bring the power of metaprogramming to the more mainstream language C , while respecting their performance concerns in that community. This paper pr...


title: Subtypes vs. Where Clauses: Constraining Parametric Polymorphism

authors:
Mark Day
Robert Gruber
Barbara Liskov
Andrew C. Myers

abstract: All object-oriented languages provide support for subtype polymorphism, which allows the writing of generic code that works for families of related types. There is also a need, however, to write code that is generic across types that have no real family relationship. To satisfy this need a programming language must provide a mechanism for parametric polymorphism, allowing for types as parameters to routines and types. We show that to support modular programming and separate compilation there must be a mechanism for constraining the actual parameters of the routine or type. We describe a simple and powerful constraint mechanism and compare it with constraint mechanisms in other languages in terms of both ease of use and semantic expressiveness. We also discuss the interaction between subtype and parametric polymorphism: we discuss the subtype relations that can exist between instantiations of parameterized types, and which of those relations are useful and can be implemented efficiently. We illustrate our points using examples in Theta, a new object-oriented language, and we describe the time- and space-efficient implementation of parametric polymorphism used in Theta.


title: Minimizing Row Displacement Dispatch Tables

authors:
Karel Driesen
Urs Hölzle

abstract: Row displacement dispatch tables implement message dispatching for dynamically-typed languages with a run time overhead of one memory indirection plus an equality test. The technique is similar to virtual function table lookup, which is, however, restricted to statically typed languages like C++. We show how to reduce the space requirements of dispatch tables to approximately the same size as virtual function tables. The scheme is then generalized for multiple inheritance. Experiments on a number of class libraries from five different languages demonstrate that the technique is effective for a broad range of programs. Finally, we discuss optimizations of the row displacement algorithm that allow dispatch table construction of these large samples to take place in a few seconds.


title: A Reflective Model for First Class Dependencies

authors:
Stéphane Ducasse
Mireille Blay-Fornarino
Anne-Marie Pinna-Dery

abstract: We propose a reflective model to express and to automatically manage dependencies between objects. This model describes reflective facilities which enable the changing of language semantics. Although the importance of inter-object dependencies is well accepted, there is only limited object-oriented language support for their specification and implementation. In response to this lack of expressiveness of object models, the FLO language integrates dependency management into the object oriented paradigm. Dependencies are described as first class objects and FLO automatically maintains the consistency of the dependency graph.In this paper, we first show how a user can declare dependencies and how the system maintains the consistency of the graph of expressed dependencies. In a second part, we focus on the implementation of this management by controlling the messages sent to linked objects. In order to make dependency management orthogonal to other application concerns, we propose an abstraction of message handling, implemented with meta-objects. We illustrate the extensibility of our language with different control behavior implementations, in particular we study different implementations of the global control of message propagation flow.


title: Sound Polymorphic Type Inference for Objects

authors:
Jonathan Eifrig
Scott F. Smith
Valery Trifonov

abstract: A polymorphic, constraint-based type inference algorithm for an object-oriented language is defined. A generalized form of type, polymorphic recursively constrained types, are inferred. These types are expressive enough for typing objects, since they generalize recursive types and F-bounded polymorphism. The well-known tradeoff between inheritance and subtyping is mitigated by the type inference mechanism. Soundness and completeness of type inference are established.


title: Release-to-Release Binary Compatibility in SOM

authors:
Ira R. Forman
Michael H. Conner
Scott Danforth
Larry K. Raper

abstract: SOM (IBM's System Object Model) removes a major impediment to reuse in Object-Oriented Programming by facilitating the programming of release-to-release binary compatible class libraries. This is accomplished by supporting a large number of compatibility preserving transformations. Taken together these transformations compose a discipline for programming evolving class libraries.


title: Patterns: Cult to Culture? - Panel Session

authors:
Steven Fraser
Grady Booch
Frank Buschmann
James Coplien
Ivar Jacobson
Norman L. Kerth
Mary Beth Rosson

abstract: Article Free Access Share on Patterns: cult to culture? Authors: Steven Fraser BNR/Nortel (Moderator) BNR/Nortel (Moderator)View Profile , Grady Booch Rational RationalView Profile , Frank Buschmann Siemens SiemensView Profile , Jim Coplien AT&T AT&TView Profile , Norm Kerth Elite Systems Elite SystemsView Profile , Ivar Jacobson Objectory ObjectoryView Profile , Mary Beth Rosson Virginia Polytechnic Institute and State University Virginia Polytechnic Institute and State UniversityView Profile Authors Info & Claims OOPSLA '95: Proceedings of the tenth annual conference on Object-oriented programming systems, languages, and applicationsOctober 1995 Pages 231–234https://doi.org/10.1145/217838.217863Online:17 October 1995Publication History 3citation600DownloadsMetricsTotal Citations3Total Downloads600Last 12 Months19Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF


title: Objects and Domain Engineering - Panel Session

authors:
Sanjiv Gossain
Don S. Batory
Hassan Gomaa
Mitchell D. Lubars
Christopher W. Pidgeon
Ed Seidewitz

abstract: Article Free Access Share on Objects and domain engineering (panel) Authors: Sanjiv Gossain Cambridge Technology Partners Cambridge Technology PartnersView Profile , Don Batory University of Texas at Austin University of Texas at AustinView Profile , Hassan Gomaa George Mason University George Mason UniversityView Profile , Mitch Lubars Scientific and Engineering Software Inc. Scientific and Engineering Software Inc.View Profile , Christopher Pidgeon Cambridge Technology Partners Cambridge Technology PartnersView Profile , Ed Seidewitz NASA Goddard Space Flight Center NASA Goddard Space Flight CenterView Profile Authors Info & Claims OOPSLA '95: Proceedings of the tenth annual conference on Object-oriented programming systems, languages, and applicationsOctober 1995Pages 333–336https://doi.org/10.1145/217838.217872Published:17 October 1995Publication History 1citation274DownloadsMetricsTotal Citations1Total Downloads274Last 12 Months19Last 6 weeks2 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF


title: Systematic Software Reuse - Panel Session

authors:
Martin L. Griss
Ted J. Biggerstaff
Sallie M. Henry
Ivar Jacobson
Doug Lea
Will Tracz

abstract: No abstract available.


title: Profile-Guided Receiver Class Prediction

authors:
David Grove
Jeffrey Dean
Charles Garrett
Craig Chambers

abstract: The use of dynamically-dispatched procedure calls is a key mechanism for writing extensible and flexible code in object-oriented languages. Unfortunately, dynamic dispatching imposes a runtime performance penalty. Some recent implementations of pure object-oriented languages have utilized profile-guided receiver class prediction to reduce this performance penalty, and some researchers have argued for applying receiver class prediction in hybrid languages like C++. We performed a detailed examination of the dynamic profiles of eight large object-oriented applications written in C++ and Cecil, determining that the receiver class distributions are strongly peaked and stable across both inputs and program versions through time. We describe techniques for gathering and manipulating profile information at varying degrees of precision, particularly in the presence of optimizations such as inlining. Our implementation of profile-guided receiver class prediction improves the performance of large Cecil applications by more than a factor of two over solely static optimizations.


title: SmartFiles: An OO Approach to Data File Interoperabilty

authors:
Matthew Haines
Piyush Mehrotra
John Van Rosendale

abstract: Data files for scientific and engineering codes typically consist of a series of raw data values whose description is buried in the programs that interact with these files. In this situation, making even minor changes in the file structure or sharing files between programs (interoperability) can only be done after careful examination of the data files and the I/O statements of the programs interacting with this file. In short, scientific data files lack self-description, and other self-describing data techniques are not always appropriate or useful for scientific data files. By applying an object-oriented methodology to data files, we can add the intelligence required to improve data interoperability and provide an elegant mechanism for supporting complex, evolving, or multidisciplinary applications, while still supporting legacy codes. As a result, scientists and engineers should be able to share datasets with far greater ease, simplifying multidisciplinary applications and greatly facilitating remote collaboration between scientists.


title: Patterns in Practice

abstract: Object-oriented systems often exhibit idiomatic and recurring structures of objects and classes that solve particular design problems and make systems more flexible, elegant, and ultimately reusable. Design patterns have been proposed as one way to represent, record and reuse these recurring design structures and associated design experience. Here we report on experiences in using design patterns during the design of object-oriented systems.


title: Managing Object Oriented Projects - Panel Session

authors:
Laura Hill
Kenneth S. Rubin
John Daniels
Charles Berman
James Coplien
Douglas Johnson

abstract: Projects using Object Oriented typically fall into one of two categories: either they are run with traditional project management techniques, or they are run by technology experts who don't use any project management techniques. This panel will attempt to give out some hints as to how to be more successful managing OO projects.Questions to be addressed include:• How is Object Oriented Project Management different? Is a paradigm shift required for project management?• What aspects of Object Oriented project management should be stressed? What are some tips, tricks or gotchas experienced by the panel members?• Does a project manager need to be more technical to lead an Object Oriented project? Should he/she have had previous experience with Object Oriented development?• What are some alternate organizational structures which would better support Object Oriented projects?• What is the nature of an Object Oriented life cycle and how is it different?• Is there a difference in techniques between different languages or between different domainsAudience members with relevant experience will be invited to sit on the panel in two guest seats.


title: A Framework for Network Protocol Software

authors:
Hermann Hüni
Ralph E. Johnson
Robert Engel

abstract: Writing software to control networks is important and difficult. It must be efficient, reliable, and flexible. Conduits+ is a framework for network software that has been used to implement the signalling system of a mullti-protocol ATM access switch. An earlier version was used to implement TCP/IP. It reduces the complexity of network software, makes it easier to extend or modify network protocols, and is sufficiently efficient. Conduits+ shows the power of a componentized object-oriented framework and of common object-oriented design patterns.


title: SCONE: Using Concurrent Objects for Low-level Operating System Programming

authors:
Jun-ichiro Itoh
Yasuhiko Yokote
Mario Tokoro

abstract: This paper proposes a methodology for making low-level system code of operating systems be replaceable at runtime. Our approach is to use concurrent objects as a basic programming unit for low-level system programs. To realize the different need for each type of system code and to execute these concurrent objects sufficiently efficient, we use a combination of dedicated system service layers and other implementation techniques. System service layers provide the most suitable primitive operations for each concurrent object. Under our programming model for low-level system code, which we call SCONE, it is possible to program low-level system code without hazardous operations such as explicit synchronization, direct scheduler manipulation, etc. We present the implementation of our methodology on the Apertos operating system and demonstrate its efficiency with performance evaluation.


title: Extending SQL-92 for OODB Access: Design and Implementation Experience

authors:
Jerry Kiernan
Michael J. Carey

abstract: This paper describes the design and implementation of a query engine that provides extended SQL-based access to the data managed by an object-oriented database system. This query engine allows extended SQL queries to be embedded in C++ programs or issued interactively as from a command line interface. The language supported by the engine is the complete SQL-92 select statement plus object extensions for navigating along paths and embedded structures, querying nested sets, and invoking member functions. In addition, an object-oriented SQL view facility is provided. Using this view facility, one can define object-oriented views; one can also define views that flatten complex OODB schemas, allowing direct access by existing tools designed to provide remote access to relational databases. The view facility also supports the definition of views that include reference and set-valued columns based on other views, thus allowing entire "view schemas" to be created. This paper describes the SQL-92 query and view extensions and discusses a number of issues that arose on the way to the implementation that is currently running on top of the ObjectStore OODB system.


title: Problem-Oriented Object Memory: Customizing Consistency

authors:
Anders Kristensen
Colin Low

abstract: This paper presents the notion of problem-oriented object memory, and its realization in a distributed object-based programming system, Penumbra. This system allows location transparent object invocation, object migration and caching. Its distinguishing feature, however, is its support for problem-oriented object sharing.Problem-oriented object memory is an object model that allows exploitation of application specific semantics by relaxing strict consistency in favour of performance.Our work addresses the problem of achieving scalability of shared write-intensive data in an environment of networked workstations. We have successfully applied the presented ideas to the management of a highly demanding telecoms application.


title: Interactive Visualization of Design Patterns Can Help in Framework Understanding

authors:
Danny B. Lange
Yuichi Nakamura

abstract: Framework programming is regarded as one the main advantages of object-oriented software engineering, and is expected to increase software reuse. In exploiting frameworks, however, programmers often face difficulties caused by the complexity of the hidden architecture and the multiplicity of the design decisions that are embedded in a framework. Interactive visualization of design patterns occurring in a framework shows how the framework is operating, in a flexible yet structured way that contributes to the programmer's understanding of the underlying software architecture. In this way, programmers can explore and use frameworks efficiently even when they are distributed without vast amounts of documentation and source code.


title: Object and Database Standards - Panel Session

authors:
Mary E. S. Loomis
R. G. G. Cattell
Frank Manola
Richard Mark Soley
Jeff Sutherland

abstract: No abstract available.


title: Lessons from the Experiences of Leading-Edge Object Technology Projects in Hewlett Packard

authors:
Ruth Malan
Derek Coleman
Reed Letsinger

abstract: A study of leading-edge HP object technology projects was conducted to understand the current state of object-oriented practice, and projects' object-oriented analysis and design method needs. In this paper, we distill general best practices and pitfalls from the lessons learned in these projects. We also consider how the OOA/D methods support what the businesses have set out to accomplish, where they are deficient, and how they are being modified to better support project needs. We draw upon these lessons to point out areas where OOA/D methods and CASE tools require improvement.


title: On the Semantic Diversity of Delegation-Based Programming Languages

abstract: The prototype-based programming model has always been difficult to characterize precisely. Its basic principle advocates concrete objects as the only mean to model concepts, yet current languages promote methodologies reintroducing abstract constructions to manage efficiently groups of similar objects. In this paper, we propose a rational reconstruction of delegation-based programming languages that identifies programming models going beyond traditional prototypes. We also introduce a new classification of delegation-based languages, which clarifies these models, and we discuss their relative merits. We finally bring to the fore the existence of more and more structured delegation-based languages forming a continuum between pure prototype-based languages and class-based ones.


title: Tailoring OO Analysis and Design Methods - Panel Session

authors:
Dennis Mancl
Frank Armour
Geoff Hambrick
Barbara Moo

abstract: Existing formalisms of inheritance are not sufficient to model the complexities of the kind of multiple inheritance exemplified in C++.Any satisfactory formalism must model the complicating effects of virtual and nonvirtual base classes as well as virtual and non-virtual methods.By abstracting the implementational notion of a subobject and formalizing subobject selection, we develop a formalism to model this combination of features.Not intended as a formal semantics of C++, the resulting model should nevertheless provide an essential level of understanding for language theorists and implementors in their dealings with C++ and related languages.


title: The Future of Distributed Object Computing - Panel Session

authors:
Bob Marcus
Robert G. Atkinson
Chris Horn
Hari Madduri

abstract: No abstract available.


title: Compiling Away the Meta-Level in Object-Oriented Concurrent Reflective Languages Using Partial Evaluation

authors:
Hidehiko Masuhara
Satoshi Matsuoka
Kenichi Asai
Akinori Yonezawa

abstract: Meta-level programmability is beneficial for parallel/distributed object-oriented computing to improve performance, etc. The major problem, however, is interpretation overhead due to mta-circular interpretation. To solve this problem, we propose a compilation framework for object-oriented concurrent reflective languages using partial evaluation. Since traditional partial evaluators do not allow us to directly deal with meta-circular interpreters written with concurrent objects, we devised techniques such as pre-/post-processing, a new proposed preaction extension to partial evaluation in order to handle side-effects, etc. Benchmarks of a prototype compiler for our language ABCL/R3 indicate that (1) the meta-level interpretation is essentially 'compiled away,' and (2) mta-level optimizations in a parallel application, running on a Fujitsu MPP AP1000, exhibits only 10--30% overhead compared to the hand-crafted source-level optimization in a non-reflective language.


title: OO Testing in the Real World: Lessons for All - Panel Session

authors:
John D. McGregor
Edward V. Berard
Donald Firesmith
Don Marick
Dav Thomson

abstract: No abstract available.


title: Towards a Methodology for Explicit Composition of MetaObjects

authors:
Philippe Mulet
Jacques Malenfant
Pierre Cointe

abstract: Reflective programming languages are those where users' programs are allowed to customize in an organized way the behavior of the language to their own needs. For ten years now, most of the work on reflection revolved around the definition and the implementation of metaobject protocols which express this organization. No methodologies have been proposed for reflective programming per se. This paper proposes a first one aiming at the design of composable metaobjects. Given two independently developed reflective customizations, this methodology proposes principles to be observed in their design such that they can be composed using standard base-level aggregation or specialization. While this paper focuses on a simple MOP and illustrates the methodology on specific examples, this methodology can be generalized to other languages with different MOPs. For instance, we discuss how to adapt it to CLOS.


title: Bidirectional Object Layout for Separate Compilation

abstract: Existing schemes for object layout and dispatch in the presence of multiple inheritance and separate compilation waste space and are slower than systems with single inheritance. This paper describes the bidirectional object layout, a new scheme for object layout that produces smaller objects and faster method invocations than existing schemes by automatically optimizing particular uses of multiple inheritance. The bidirectional object layout is used for the programming language Theta, and is applicable to languages like C++. This paper also demonstrates how to efficiently implement method dispatch when method signatures are allowed to change in subclasses. Most current statically compiled languages require identical signatures for efficiency. 1 Introduction Existing schemes for object memory layout and method dispatch in statically typed languages with multiple inheritance assume the use of multiple inheritance in its full generality. These schemes incur high per-object space overhea...


title: Subject-Oriented Composition Rules

authors:
Harold Ossher
Matthew Kaplan
William H. Harrison
Alexander Katz
Vincent J. Kruskal

abstract: Subject-oriented programming supports composition of object-oriented programs or program fragments called subjects. This paper presents an approach to the composition rules used to specify composition details. Rules can be generic, allowing different subrules to be "plugged into" higher-level rules, and they include a means of specifying exceptions to general rules. We give definitions of a number of useful, generic rules, including merge and override, as a first step towards a generally-useful composition rule library. We also outline an object-oriented framework for implementing rules, which we are currently building as part of our support for subject-oriented programming in C++.


title: How and Why to Encapsulate Class Trees

abstract: A good reusable framework, pattern or module interface usually is represented by abstract classes. They form an abstract design and leave the implementation to concrete subclasses. The abstract design is instantiated by naming these subclasses. Unfortunately, this exposes implementation details like class names and class tree structures. The paper gives a rationale and a general metaobject protocol design that encapsulates whole class trees. Clients of an abstract design retrieve classes and create objects based on class semantics specifications. Using abstract classes as the only interface enhances information hiding and makes it easier both to evolve a system and to configure system variants.


title: An Algebraic Semantics of Subobjects

authors:
Jonathan G. Rossie Jr.
Daniel P. Friedman

abstract: Existing formalisms of inheritance are not sufficient to model the complexities of the kind of multiple inheritance exemplified in C++. Any satisfactory formalism must model the complicating effects of virtual and nonvirtual base classes as well as virtual and non-virtual methods. By abstracting the implementational notion of a subobject and formalizing subobject selection, we develop a formalism to model this combination of features. Not intended as a formal semantics of C++, the resulting model should nevertheless provide an essential level of understanding for language theorists and implementors in their dealings with C++ and related languages. 1 Introduction The style of multiple inheritance first proposed for Simula by Krogdahl[21] and later developed into the C++ multiple inheritance system by Stroustrup[35, 15] exemplifies a particular kind of inheritance in which the underlying imperative is to maintain the integrity of subobjects. Subobjects are historically an implementation...


title: Object-Oriented State Machines: Subclassing, Composition, Delegation and Genericity

authors:
Aamod Sane
Roy H. Campbell

abstract: Software specification and implementation techniques based on state machines simplify design, coding, and validation. However, large systems require complex state machines. Incremental construction techniques can control this complexity. In this paper, we present a construction technique that permits derivation of complex state machines from simpler state machines. The technique uses subclassing, composition, delegation, and genericity to incrementally modify and combine simpler machines.In addition, we present a novel implementation technique that uses exactly one table-lookup and one addition to dispatch events on derived state machines, no matter the depth of the derivation. As an example, we describe the derivation of a complicated distributed virtual memory scheme from a simple paging virtual memory scheme.


title: Creating the Architecture of a Manufacturing Framework by Design Patterns

abstract: The class and interaction structure of object-oriented designs may become fairly complex, and consequently difficult to develop and understand.Design patterns allow to govern this complexity.This paper presents the design process of a domain-specific black-box framework for the control of automated manufacturing systems.The design is performed as a sequence of transformation steps, guided by the use of generative design patterns.Starting out from a domain-specific model.which does not provide a degree of reusability sufficiently high for a framework.the transformation steps increase the reusability until a satisfactory degree is reached.The resulting class and interaction structure allows to create each application of the considered manufacturing subdomain by selecting, configuring and parameterizing of the framework classes.


title: Using a Prototype-based Language for User Interface: The Newton Project's Experience

abstract: Object-oriented user interface frameworks are usually implemented in a class-based language. We chose instead to develop a prototype-based language, NewtonScript, for this purpose. We found that prototype inheritance has compelling advantages over classes in the domain of user interface programming, and can help overcome the memory constraints of a small machine.


title: The Self-4.0 User Interface: Manifesting a System-wide Vision of Concreteness, Uniformity and Flexibility

authors:
Randall B. Smith
John Maloney
David M. Ungar

abstract: Manipulating programs is hard, while manipulating objects in the physical world is often easy. Several attributes of the physical world help make it comprehensible and manipulable: concreteness, uniformity, and flexibility. The Self programming system attempts to apply these attributes to the world within the computer. The semantics of the language, the efficiency and fidelity of its implementation, and the architecture of its user interface conspire to make the experience of constructing programs in Self immediate and tangible. We describe the mechanisms used to achieve this goal, and illustrate those mechanisms within the context of an extended programming task.


title: Modular Reasoning in the Presence of Subclassing

authors:
Raymie Stata
John V. Guttag

abstract: Considerable progress has been made in understanding how to use subtyping in a way that facilitates modular reasoning. However, using subclassing in a way that facilitates modular reasoning is not well understood. Often methods must be overriden as a group because of dependencies on instance variables, and the programmers of subclasses cannot tell which methods are grouped without looking at the code of superclasses. Also, the programmers of subclasses must look at the code of superclasses to tell what assumptions inherited methods make about the behavior of overriden methods.We present a systematic way to use subclassing that facilitates formal and informal modular reasoning. Separate specifications are given to programmers writing code that manipulates instances of a class and to programmers writing subclasses of the class. The specifications given to programmers of subclasses are divided, by division of labor specifications, into multiple parts. Subclasses may inherit or override entire parts, but not sub-parts. Reasoning about the implementation of each part is done independently of other parts.


title: Annotating Objects for Transport to Other Worlds

abstract: In Self 4.0, people write programs by directly constructing webs of objects in a larger world of objects. But in order to save or share these programs, the objects must be moved to other worlds. However, a concrete, directly constructed program is incomplete, in particular missing five items of information: which module to use, whether to transport an actual value or a counterfactuaI initial value, whether to create a new object in the new world or to refer to an existing one, whether an object is immutable with respect to transportation, and whether an object should be created by a low-level, concrete expression or an abstract, type-specific expression. In Self 4.0, the programmer records this extra information in annotations and attributes. Any system that saves directly constructed programs will have to supply this missing information somehow.


title: Lessons from the Battlefield

abstract: The pragmatic aspects of deploying large scale Object Oriented (OO) applications are examined. The focus is on identifying some of the main obstacles that arise in typical large scale OO projects, and offering hints about effective solutions. This The topics are based on a number of actual large scale projects in which the author participated in a It significant capacity and solutions that he adopted or developed to deal with the problems encountered.


title: Code Reuse in an Optimizing Compiler

authors:
Ali-Reza Adl-Tabatabai
Thomas R. Gross
Guei-Yuan Lueh

abstract: This paper describes how the cmcc compiler reuses code---both internally (reuse between different modules) and externally (reuse between versions for different target machines). The key to reuse are the application frameworks developed for global data-flow analysis, code generation, instruction scheduling, and register allocation.The code produced by cmcc is as good as the code produced by the native compilers for the MIPS and SPARC, although significantly less resources have been spent on cmcc (overall, about 6 man years by 2.5 persons). cmcc is implemented in C++, which allowed for a compact expression of the frameworks as class hierarchies. The results support the claim that suitable frameworks facilitate reuse and thereby significantly improve developer effectiveness.


title: Semantic-Based Visualization for Parallel Object-Oriented Programming

authors:
Isabelle Attali
Denis Caromel
Sidi O. Ehmety
Sylvain Lippi

abstract: We present a graphical environment for parallel object-oriented programming. It provides visual tools to develop and debug object-oriented programs as well as parallel or concurrent systems. This environment was derived from a structural operational semantics of an extension of the Eiffel language, Eiffel//. Object-related features of the language (inheritance, polymorphism) are formalized using a big-step semantics, while the interleaving model of concurrency is expressed with small-step semantics.Without user instrumentation, the interactive environment proposes features such as step-by-step animated executions, graphical visualization of object and process topology, futures and pending requests, control of interleaving, deadlock detection.


title: Fast Static Analysis of C++ Virtual Function Calls

authors:
David F. Bacon
Peter F. Sweeney

abstract: Virtual functions make code easier for programmers to reuse but also make it harder for compilers to analyze. We investigate the ability of three static analysis algorithms to improve C++ programs by resolving virtual function calls, thereby reducing compiled code size and reducing program complexity so as to improve both human and automated program understanding and analysis. In measurements of seven programs of significant size (5000 to 20000 lines of code each) we found that on average the most precise of the three algorithms resolved 71% of the virtual function calls and reduced compiled code size by 25%. This algorithm is very fast: it analyzes 3300 source lines per second on an 80 MHz PowerPC 601. Because of its accuracy and speed, this algorithm is an excellent candidate for inclusion in production C++ compilers.


title: Split Objects: a Disciplined Use of Delegation within Objects

authors:
Daniel Bardou
Christophe Dony

abstract: This paper's primary aim is to improve the understanding of the delegation mechanism as defined in [18]. We propose a new characterization of delegation based on the notions of name sharing, property sharing and value sharing. It allows us (1) to clearly differentiate delegation from class-inheritance in particular and more generally from other inheritance mechanisms and (2) to explain how a founded use of delegation relies on a correct semantics of variable property sharing between objects connected by a delegation link. We then describe a model of split objects which is proposed as an example of a disciplined and semantically founded use of delegation, where property sharing expresses viewpoints within objects.


title: A Monotonic Superclass Linearization for Dylan

authors:
Kim Barrett
Bob Cassels
Paul Haahr
David A. Moon
Keith Playford
P. Tucker Withington

abstract: Object-oriented languages with multiple inheritance and automatic conflict resolution typically use a linearization of superclasses to determine which version of a property to inherit when several superclasses provide definitions. Recent work has defined several desirable characteristics for linearizations, the most important being monotonicity, which prohibits inherited properties from skipping over direct superclasses. Combined with Dylan's sealing mechanism, a monotonic linearization enables some compile-time method selection that would otherwise be impossible in the absence of a closed-world assumption.The Dylan linearization is monotonic, easily described, strictly observes local precedence order, and produces the same ordering as CLOS when that is monotonic. We present an implementation based on merging and a survey of class heterarchies from several large programs, analyzing where commonly used linearizations differ.


title: Components on the Internet (Panel Session)

authors:
Jeffrey Bonar
Nancy Lehrer
Kelly Looney
Stewart Nickolas
James Russell
Randy Schnier
Ted Selker

abstract: The explosive emergence of the Internet forces us to rethink the traditional roles for client, server, and objects. Component technology has emerged as the way objects and frameworks are packaged for flexible object integration. In particular, components allow users who are not programmers to do their own integration. Up until now, components have mainly focused on object integration on end-users desktops and on a client: compound documents, application assembly, etc.Existing component models like OpenDoc and Microsoft's OLE/OCX/COM provide function for compound documents, persistence, scripting, inking, and code management (registration). A series of Internet scenarios are emerging that demand new kinds of components. These scenarios are thin clients (Internet terminals), virtual reality/rich multimedia clients, collaboration, and business data access. Each panelist will explore one of these scenarios for it's requirements on an Internet component model.


title: Perspectives on Reuse (Panel Session)

authors:
Lorette Cameron
Charles Berman
Sanjiv Gossain
Brian Henderson-Sellers
Laura Hill
Randall B. Smith

abstract: Reuse is about more than sharing code. As technology, standards and ideas evolve: so do the artifacts available for reuse. Our understanding of the non-technical issues associated with reuse also progresses. This panel will look at reuse from 5 different perspectives. We will look at the reuse of design patterns and of services in a service-based, distributed architecture as examples of artifacts relatively new to the corporate world. We will also focus on the psychological factors affecting the success of reuse programs along with organizational modifications and measurement techniques that will help make reuse work. Lastly, we will take a look at how certain kinds of reuse can affect the success of a project at the user level, and what this might imply for measuring the effectiveness of our reuse programs. The audience will leave with some concrete ideas about how to implement and measure reuse program as well as new thoughts on what artifacts may be reused.


title: Soft Issues in Software Development (Panel Session)

authors:
Paul S. R. Chisholm
Larry L. Constantine
Ward Cunningham
Luke Hohmann
Norman L. Kerth

abstract: The key to making object technology work isn't technology. So what is it? This panel will cover a lot of the "soft" issues about dealing with people and teams. It's partly about managing software development, and mostly about doing it.


title: Vortex: An Optimizing Compiler for Object-Oriented Languages

authors:
Jeffrey Dean
Greg DeFouw
David Grove
Vassily Litvinov
Craig Chambers

abstract: Previously, techniques such as class hierarchy analysis and profile-guided receiver class prediction have been demonstrated to greatly improve the performance of applications written in pure object-oriented languages, but the degree to which these results are transferable to applications written in hybrid languages has been unclear. In part to answer this question, we have developed the Vortex compiler infrastructure, a language-independent optimizing compiler for object-oriented languages, with front-ends for Cecil, C++, Java, and Modula-3. In this paper, we describe the Vortex compiler's intermediate language, internal structure, and optimization suite, and then we report the results of experiments assessing the effectiveness of different combinations of optimizations on sizable applications across these four languages. We characterize the benchmark programs in terms of a collection of static and dynamic metrics, intended to quantify aspects of the "object-orientedness" of a program.


title: On Automatic Class Insertion with Overloading

authors:
Hervé Dicky
Christophe Dony
Marianne Huchard
Thérèse Libourel

abstract: Several algorithms [Cas92, MS89, Run92, DDHL94a, DDHL95, GMM95] have been proposed to automatically insert a class into an inheritance hierarchy. But actual hierarchies all include overriden and overloaded properties that these algorithms handle either very partially or not at all. Partially handled means handled provided there is a separate given function f able to compare overloaded properties [DDHL95, GMM95].In this paper, we describe a new version of our algorithm (named Ares) which handles automatic class insertion more efficiently using such a function f. Although impossible to fully define, this function can be computed for a number of well defined cases of overloading and overriding. We give a classification of such cases and describe the computation process for a well-defined set of nontrivial cases.The algorithm preserves these important properties:- preservation of the maximal factorization of properties- preservation of the underlying structure (Galois lattice) of the input hierarchy- conservation of relevant classes of the input hierarchy with their properties.


title: Simple and Effective Analysis of Statically Typed Object-Oriented Programs

authors:
Amer Diwan
J. Eliot B. Moss
Kathryn S. McKinley

abstract: To use modern hardware effectively, compilers need extensive control-flow information. Unfortunately, the frequent method invocations in object-oriented languages obscure control flow. In this paper, we describe and evaluate a range of analysis techniques to convert method invocations into direct calls for statically-typed object-oriented languages and thus improve control-flow information in object-oriented languages. We present simple algorithms for type hierarchy analysis, aggregate analysis, and interprocedural and intraprocedural type propagation. These algorithms are also fast, O(|procedures| * ∑pprocedure np * vp) worst case time (linear in practice) for our slowest analysis, where np is the size of procedure p and vp is the number of variables in procedure p, and are thus practical for use in a compiler. When they fail, we introduce cause analysis to reveal the source of imprecision and suggest where more powerful algorithms may be warranted. We show that our simple analyses perform almost as well as an oracle that resolves all method invocations that invoke only a single procedure.


title: The Direct Cost of Virtual Function Calls in C++

authors:
Karel Driesen
Urs Hölzle

abstract: We study the direct cost of virtual function calls in C++ programs, assuming the standard implementation using virtual function tables. We measure this overhead experimentally for a number of large benchmark programs, using a combination of executable inspection and processor simulation. Our results show that the C++ programs measured spend a median of 5.2% of their time and 3.7% of their instructions in dispatch code. For "all virtuals" versions of the programs, the median overhead rises to 13.7% (13% of the instructions). The "thunk" variant of the virtual function table implementation reduces the overhead by a median of 21% relative to the standard implementation. On future processors, these overheads are likely to increase moderately.


title: A Framework for Run-Time Systems and its Visual Programming Language

authors:
Alan M. Durham
Ralph E. Johnson

abstract: Frameworks and domain-specific visual languages are two different reuse techniques, the first targeted at expert programmers, the second at domain experts. In fact, these techniques are closely related. This paper shows how to develop a domain-specific visual language by first developing a white-box framework for the domain, then turning it into a black-box framework, and finally building a graphical front end for it. We used this technique in a compiler to specify run-time systems.


title: The Basic Object System: Supporting a Spectrum From Prototypes To Hardened Code

authors:
Allen H. Dutoit
Sean Levy
Douglas Cunningham
Robert Patrick

abstract: BOS is a prototype-based, object-oriented toolkit aimed at better supporting evolutionary software development. BOS attempts to support a spectrum of activities in one environment---ranging from rapid prototyping to code hardening. Features enabling rapid prototyping include a prototype-based object model, an interpreted language, run-time argument constraints, position and keyword arguments, and a user interface toolkit. BOS also provides features for code hardening such as multi-methods, multiple inheritance, external code wrapping mechanisms, and interfaces to other packages such as database management systems. BOS thus enables the end-to-end programming of software in an integrated and unified environment. BOS has been used to develop several full-size applications which have been evaluated and delivered externally.


title: Change Cases: Use Cases that Identify Future Requirements

authors:
Earl F. Ecklund Jr.
Lois M. L. Delcambre
Michael J. Freiling

abstract: Evolution of software systems is prompted by all sorts of changes. This paper demonstrates how the use case, a well known construct in object-oriented analysis, is adapted to form the change case, to identify and articulate anticipated system changes. A change case provides the ability to identify and incorporate expected future change into a design to enhance the long-term robustness of that design. In this paper, we define change cases and demonstrate how change cases are captured by the analyst. We present examples to illustrate how change cases can influence present system design and point the way toward designs that more easily accommodate expected future changes. Change cases can be effectively employed in the context of any methodology that supports use cases and traceability links.


title: OO Anthropology: Crossing the Chasm (Panel Session)

authors:
Steven Fraser
Alistair Cockburn
Leo Brajkovich
James Coplien
Larry L. Constantine
Dave West

abstract: Anthropology is the study of civilization, particularly its societies, customs, structure, and evolution. Our premise is that there are cultureal "chasms" to be crossed to ensure the success of the technological beachhead established by innovators and early adopters of the OO paradigm. Our panelists will address the following questions:•What anthropological cultural factors have to be "matured" (and how?) to foster the success of the OO paradigm?•What mechanisms are required to facilitate communications between cultures of differing maturity?•What cultural chasms must be crossed to develop a successful organization/culture within the framework supported by the object-oriented paradigm (or more perrversely, is there anything "special" about the OO paradigm)?This panel will interest pracitioners as a forum to share and debate experiences related to our current-day software culture metamorphosis.


title: Translation: Myth or Reality? (Panel Session)

authors:
Steven Fraser
Robert C. Martin
Stephen J. Mellor
Michael Lee
Grady Booch
Stephen Garone
Martin Fowler
Douglas C. Schmidt
Marie Lenzi

abstract: In the realm of OO methodologies there are two major schools of thought. Both schools claim to define mechanisms whereby software applications can be created that are reusable, maintainable, and robust. Moreover, both schools claim to use abstraction as a key mechanism for achieving these benefits. At issue is whether or not these two schools are fundamentally different, or just variations on an object-oriented theme.Shlaer and Mellor have dubbed one of these schools Translational. In the translational approach, two models are created. One is an abstract model of the application domain which is devoid of any design dependencies. The other model is an abstract model of the design which is devoid of any application dependencies. These two models are composed automatically to yield the code for the system.The other school - supported by Booch, Rumbaugh, Jacobson, and Martin - views the architecture of a system from several different perspectives of abstraction, e.g. logical, physical. These abstractions typically form a layer; abstractions in the logical sense manifest themselves as individual classes as well as collaborations of classes. There may be one layered model, at different layers of abstraction, or, especially given the Objectory view point, there may be multiple models, with an analysis model that's nearly independent from the design model.The panel will explore:• Is there a seamless transition between analysis and design?• Should there be a single model or should there be two - one for the analysis and one for the design?• If there are two models, how are they bridged?• What, if any, are the differences in process between the two schools?• How does architecture manifest itself!• Is there, in fact, a real difference between the two schools of thought?As a result of this exploration, we hope to answer the question: Is translation a myth or is it a reality?


title: Environmental Acquisition - A New Inheritance-Like Abstraction Mechanism

authors:
Joseph Gil
David H. Lorenz

abstract: The class of an object is not necessarily the only determiner of its runtime behaviour. Often it is necessary to have an object behave differently depending upon the other objects to which it is connected. However, as it currently stands, object-oriented programming provides no support for this concept, and little recognition of its role in common, practical programming situations. This paper investigates a new programming paradigm, environmental acquisition in the context of object aggregation, in which objects acquire behaviour from their current containers at runtime. The key idea is that the behaviour of a component may depend upon its enclosing composite(s). In particular, we propose a form of feature sharing in which an object "inherits" features from the classes of objects in its environment. By examining the declaration of classes, it is possible to determine which kinds of classes may contain a component, and which components must be contained in a given kind of composite. These relationships are the basis for language constructs that supports acquisition. We develop the theory of acquisition that includes topics such as the kinds of links along which acquisition may occur, and the behaviour of routine (methods) and attribute features under acquisition. The proposed model for acquisition as a hierarchical abstraction mechanism is a strongly typed model that allows static type checking of programs exploiting this mechanism. We compare it to several other mechanisms including inheritance and delegation, and show that it is significantly different than these.


title: A Flexible Operation Execution Model for Shared Distributed Objects

authors:
Saniya Ben Hassen
Irina Athanasiu
Henri E. Bal

abstract: Many parallel and distributed programming models are based on some form of shared objects, which may be represented in various ways (e.g., single-copy, replicated, and partitioned objects). Also, many different operation execution strategies have been designed for each representation. In programming systems that use multiple representations integrated in a single object model, one way to provide multiple execution strategies is to implement each strategy independently from the others. However, this leads to rigid systems and provides little opportunity for code reuse. Instead, we propose a flexible operation execution model that allows the implementation of many different strategies, which can even be changed at runtime. We present the model and a distributed implementation of it. Also, we describe how various execution strategies can be expressed using the model, and we look at applications that benefit from its flexibility. 1 Introduction Shared objects have become a popular model...


title: Formal Design Constraints

authors:
Nils Klarlund
Jari Koistinen
Michael I. Schwartzbach

abstract: Large software systems are often built on system platforms that support or enforce specific characteristics of the source code or actual design. These characteristics are either captured informally in design guideline documents or in specialized design and implementation languages.In our view, both approaches are unsatisfactory. Informal descriptions do not allow automated analysis and lead to vague constraint descriptions. The language-based approach leads to different languages for different platforms and even for different versions of the same basic platform.Our approach is to describe and name the constraints separately in a design constraint language called CDL, which is based on an extraordinarily concise logic of parse trees. Designs are then annotated with the names of the constraints they are supposed to satisfy.We discuss how the design constraint language is integrated into a design language environment. We exhibit industrial and experimental evidence that our choice of design constraint language allows us to formalize naturally and succinctly common design characteristics.


title: Lessons Learned from Implementing the CORBA Persistent Object Service

authors:
Jan Kleindienst
Frantisek Plásil
Petr Tuma

abstract: In this paper, the authors share their experiences gathered during the design and implementation of the CORBA Persistent Object Service. There are two problems related to a design and implementation of the Persistence Service: first, OMG intentionally leaves the functionality core of the Persistence Service unspecified; second, OMG encourages reuse of other Object Services without being specific enough in this respect. The paper identifies the key design issues implied both by the intentional lack of OMG specification and the limits of the implementation environment characteristics. At the same time, the paper discusses the benefits and drawbacks of reusing other Object Services, particularly the Relationship and Externalization Services, to support the Persistence Service. Surprisingly, the key lesson learned is that a direct reuse of these Object Services is impossible.


title: A Functional Layer for Description Logics: Knowledge Representation Meets Object-Oriented Programing

abstract: The paper motivates the facilities provided by Description Logics in an object-oriented programming scenario. It presents a unification approach of Description Logics and object-oriented programming that allows both views to be conveniently used for different subproblems in a modern software-engineering environment. The main thesis of this paper is that in order to use Description Logics in practical applications, a seamless integration with object-oriented system development methodologies must be realized.


title: Automatic Inheritance Hierarchy Restructuring and Method Refactoring

abstract: Most, object-oriented programs have imperfectly designed inheritance hierarchies and imperfectly factored methods, and these imperfections tend to increase with maintenance. Hence, even object-oriented programs are more expensive to maintain, harder to understand and larger than necessary. Automatic restructuring of inheritance hierarchies and refactoring of methods can improve the design of inheritance hierarchies, and the factoring of methods. This results in programs being smaller, having better code re-use and being more consistent. This paper describes Guru, a prototype tool for automatic inheritance hierarchy restructuring and method refactoring of Self programs. Results from realistic applications of the tool are presented.


title: An Equational Object-Oriented Data Model and its Data-Parallel Query Language

authors:
Susumu Nishimura
Atsushi Ohori
Keishi Tajima

abstract: This paper presents an equational formulation of an object-oriented data model. In this model, a database is represented as a system of equations over a set of oid's, and a database query is a transformation of a system of equations into another system of equations. During the query processing, our model maintains an equivalence relation over oid's that relates oid's corresponding to the same "real-world entity." By this mechanism, the model achieves a declarative set-based query language and views for objects with identity. Moreover, the query primitives are designed so that queries including object traversal can be evaluated in a data-parallel fashion.


title: Reorganizing Split Objects

abstract: Object-based (i.e. classless) models are very effective for elucidating requirements from users, and they support exploratory programming and rapid prototyping, providing a direct manipulation approach. On the other hand, class-based models have powerful mechanisms to control redundancy, exploit sharing, express extension, and propagate changes to instances.The price object-based approaches pay is loss of control over change propagation, and potential redundancy. Two mechanisms to overcome this are sharing among objects and definition of objects as extension of others. We examine these mechanisms, and consider the effect that interacting policies for objects sharing and definition-by-extension have on change propagation and replication control. An implication is that, in absence of meta-objects or extra-language support, monolithic shared parts cannot coexist with prototypes represented as split objects.


title: Architecture-Oriented Visualization

authors:
Mohlalefi Sefika
Aamod Sane
Roy H. Campbell

abstract: Tracking the changing dynamics of object-oriented frameworks[5], design patterns[7], architectural styles[8], and subsystems during the development and reuse cycle can aid producing complex systems. Unfortunately, current object-oriented programming tools are relatively oblivious to the rich architectural abstractions in a system.This paper shows that architecture-oriented visualization, the graphical presentation of system statics and dynamics in terms of its architectural abstractions, is highly beneficial in designing complex systems. In addition, the paper presents architecture-aware instrumentation, a new technique for building efficient on-line instrumentation to support architectural queries. We demonstrate the effectiveness and performance of the scheme with case studies in the design of the Choices object-oriented operating system.


title: Objects on the Server: Are We Ready? (Panel Session)

authors:
Yen-Ping Shan
Tom Morgan
Phil Proudfoot
Jim Thompson
John Tibbetts
Al Woolfrey

abstract: Object-oriented concepts such as reuse and encapsulation offer many benefits to application development, particularly in managing complexity and change. All the benefits of OO that apply to the client can apply equally well to the server. However, until recently, these concepts have proven to benefit only the client side. Could there be any intrinsic or conceptual reason for this? Or could it be a result of timing, the availability of the tools, and the conservative restraints that result from the mission-critical nature of server computing?This panel will explore the roles of objects on the server by examining the experiences of the panelists from a technology consumer's perspective. By doing so, we would like to provide insights for corporations that are making decisions on OO technology, point out pitfalls along the way, and identify potential opportunities for technology providers.All panelists have developed production level object servers. The panel will answer the question of whether we are ready for object servers by discussing the following issues:• Different server types: transactional server, data server, application server, web server, etc. Are they really that much different? Which one is the most important kind?• Experience in implementing and maintaining object systems on the server: the configurations of the systems and how they were arrived at; the tools and programming languages used.• Benefits and drawbacks of server object systems.• What's hard? What's easy?• What are the prerequisites for pervasive deployments of objects on the server? (e.g., standards, application types, customer situations, tools, and languages.)• What would be desirable for technology providers (researchers and vendors) to provide? (Tools, languages, execution environments that represents vendor opportunities.)• Practical advice to organizations interested in introducing objects to the server.


title: Reuse Contracts: Managing the Evolution of Reusable Assets

authors:
Patrick Steyaert
Carine Lucas
Kim Mens
Theo D'Hondt

abstract: A critical concern in the reuse of software is the propagation of changes made to reusable artifacts. Without techniques to manage these changes, multiple versions of these artifacts will propagate through different systems and reusers will not be able to benefit from improvements to the original artifact. We propose to codify the management of change in a software system by means of reuse contracts that record the protocol between managers and users of a reusable asset. Just as real world contracts can be extended, amended and customised, reuse contracts are subject to parallel changes encoded by formal reuse operators: extension, refinement and concretisation. Reuse contracts and their operators serve as structured documentation and facilitate the propagation of changes to reusable assets by indicating how much work is needed to update previously built applications, where and how to test and how to adjust these applications.


title: Slicing Class Hierarchies in C++

authors:
Frank Tip
Jong-Deok Choi
John Field
G. Ramalingam

abstract: This paper describes an algorithm for slicing class hierarchies in C++ programs. Given a C++ class hierarchy (a collection of C++ classes and inheritance relations among them) and a program P that uses the hierarchy, the algorithm eliminates from the hierarchy those data members, member functions, classes, and inheritance relations that are unnecessary for ensuring that the semantics of P is maintained.Class slicing is especially useful when the program P is generated from a larger program P' by a statement slicing algorithm. Such an algorithm eliminates statements that are irrelevant to a set of slicing criteria---program points of particular interest. There has been considerable previous work on statement slicing, and it will not be the concern of this paper. However, the combination of statement slicing and class slicing for C++ has two principal applications: First, class slicing can enhance statement slicing's utility in program debugging and understanding applications, by eliminating both executable and declarative program components irrelevant to the slicing criteria. Second, the combination of the two slicing algorithms can be used to decrease the space requirements of programs that do not use all the components of a class hierarchy. Such a situation is particularly common in programs that use class libraries.


title: Using Role Components to Implement Collaboration-Based Designs

authors:
Michael VanHilst
David Notkin

abstract: In this paper we present a method of code implementation that works in conjunction with collaboration and responsibility based analysis modeling techniques to achieve better code reuse and resilience to change. Our approach maintains a closer mapping from responsibilities in the analysis model to entities in the implementation. In so doing, it leverages the features of flexible design and design reuse found in collaboration-based design models to provide similar adaptability and reuse in the implementation. Our approach requires no special development tools and uses only standard features available in the C++ language. In an earlier paper we described the basic mechanisms used by our approach and discussed its advantages in comparison to the framework approach. In this paper we show how our approach combines code and design reuse, describing specific techniques that can be used in the development of larger applications.


title: A Situated Evaluation of the Object Management Group's (OMG) Object Management Architecture (OMA)

authors:
Evan Wallace
Kurt C. Wallnau

abstract: It has been difficult to objectively assess the real value or maturity of the Object Management Group's Object Management Architecture (OMA). While experience reports have appeared in the literature, these have focused more on the functionality of the end-system than on systematically exploring the strengths and weaknesses of the OMA, and providing practical guidelines on the effective use of the OMA for specific software-engineering problems. In this paper we describe a case study in the use of the OMA to integrate legacy software components into a distributed object system. We assess the OMA in this problem context, and indicate strengths and weaknesses of the specification and current implementations. We extrapolate our experience to a broader class of component-based software systems, and recommend an architectural strategy for the effective use of the OMA to this class of systems.


title: Creating Host Compliance in a Portable Framework: A Study in the Use of Existing Design Patterns

abstract: This report describes an experiment carried out at ParcPlace-Digitalk which sought to increase the look-and-feel compliance of portable applications built using the company's Smalltalk-based VisualWorks product. We outline the structure of the current VisualWorks user interface framework, and the precise requirements which the experimental system sought to fulfill. We go on to show how we were able to reuse design patterns from the literature in a generative fashion, to direct the evolution of the new framework. This contrasts with most pattern-related work to date, which has concentrated on discerning design patterns in existing systems. Finally, we draw generalizations from our experience concerning the evolution of software architecture using patterns.


title: Adding Type Parameterization to the Java Language

authors:
Ole Agesen
Stephen N. Freund
John C. Mitchell

abstract: Although the Java programming language has achieved widespread acceptance, one feature that seems sorely missed is the ability to use type parameters (as in Ada generics, C++ templates, and ML polymorphic functions or data types) to allow a general concept to be instantiated to one or more specific types. In this paper, we propose parameterized classes and interfaces in which the type parameter may be constrained to either implement a given interface or extend a given class. This design allows the body of a parameterized class to refer to methods on objects of the parameter type, without introducing any new type relations into the language. We show that these Java extensions may be implemented by expanding parameterized classes at class load time, without any extension or modification to existing Java bytecode, verifier or bytecode interpreter.


title: The ODMG Object Model: Does it Make Sense?

abstract: The ODMG Object Model is shown to have a number of problems. A major confusion is caused by the intended type of polymorphism and the way it is expressed in the Model. Dynamic type checking is required even in situations when static type checking is possible. There are situations in which there is no way that type checking can determine whether a particular construct is type correct or not. The model of persistence in the ODMG Standard is not orthogonal, which has undesirable pragmatic consequences on complex objects. The discrepancies between the ODMG Object Model and the particular language bindings of the ODMG Standard are non-trivial. This paper presents solutions to some of these problems together with the associated formal system. Without such a formal system the recommended ODMG bindings are open to a wide range of different, and sometimes confusing interpretations. The criticism expressed in the paper is intended to be helpful in developing future releases of the ODMG Standard.


title: Looking for the Objects in Object-Relational DBMSs (Panel)

authors:
Lougie Anderson
Michael J. Carey
Kenneth R. Jacobs
Erin Kinikin
David Maier

abstract: The Relational Model first came into vogue in the early 1980's. It was based on the simplifying idea that all data could be modeled as mathematical relations (tables in "normal form"). Permissible operations on this table data structure were specified by the relation algebra and calculus. The Relational Model led to years of research in areas such as query languages, query optimization, transaction models, and database design methodologies. This research has dominated DBMS conferences for the last fifteen years and has also lead to major products offerings in wide-spread use in the computer industry today.While the Relational revolution was happening in the DBMS community there was a minority opinion emerging from the object community. This minority opinion surfaced in heated debates and panels at DBMS conferences where it was often pitted against "relational purists." The object proponents wanted to discuss storing and retrieving complex objects and relationships in databases while the relational purists insisted on maintaining "mathematical purity and simplicity". These panels were often some of the most acrimonious (and entertaining) at these conferences and many thought there was no way to bridge the chasm between the two schools of thought.However times changes and so do the realities of the commercial world. Object languages such as C++, Smalltalk, and Java have become de facto standards. The Internet and the PC have increased the demand for complex data types. And the relational model is evolving to accommodate these realities.All of the major RDBMS vendors have announced plans for, or are already shipping, Object-Relational DBMS (ORDBMS) products. A natural question for the object community is how well these new products will address the well-known "impedance mismatch" between a pure object model and the relational model. For example, how does one make Java, Smalltalk, or C++ objects persist using an ORDBMS? Can one search for these objects in the database using their methods?The vendors for ORDBMS are claiming well-known OO features in their implementations, such as extensible data types, inheritance, object identity, and object language bindings. This panel will allow the major vendors to explain how those features match up with the kinds of object models that OO developers are accustomed to. The panel will consist of representatives from three of the major ORDBMS vendors as well as a representative of "pure object think". The vendor representatives will each present a brief overview of the object-related features of their products and will explain why OO programmers are going to have an easier time with these ORDBMSs. This will be followed by counterpoint discussion from the pure object thinker.


title: Parasitic Methods: An Implementation of Multi-Methods for Java

authors:
John Boyland
Giuseppe Castagna

abstract: In an object-oriented programming language, method selection is (usually) done at run-time using the class of the receiver. Some object-oriented languages (such as CLOS) have multi-methods which comprise several methods selected on the basis of the runtime classes of all the parameters, not just the receiver. Multi-methods permit intuitive and typesafe definition of binary methods such as structural equality, set inclusion and matrix multiplication, just to name a few. Java as currently defined does not support multimethods. This paper defines a simple extension to Java that enables the writing of "encapsulated" multi-methods through the use of parasitic methods, methods that "attach" themselves to other methods. Encapsulated multi-methods avoid some of the modularity problems that, arise with fully general multi-methods. Furthermore, this. extension yields for free both covariant and contravariant specialization of methods (besides Java's current invariant specialization).Programs using this extension. can be translated automatically at the source level into programs that do not; they are modular, type-safe, and allow separate compilation.


title: UML: The Language of Blueprints for Software? (Panel)

authors:
Derek Coleman
John Artim
Victor Ohnjec
Erick Rivas
James E. Rumbaugh
Rebecca Wirfs-Brock

abstract: The Unified Method was launched by Grady Booch and Jim Rumbaugh at an OOPSLA'95 Conference Fringe meeting organised by Rational Software Corporation. In 1996 Unified Method was re-scoped to a notation, and renamed Unified Modeling Language (UML).Earlier this year, UML was submitted to Object Management Group for standardisation and has been endorsed by Microsoft, IBM, HP, Platinum Technologies, ObjectTime and many other corporations. No wonder UML is leading contender as de facto standard notation for object-oriented analysis and design.The panel will take a sanity check, and will go beyond hype and newsgroup flames and attempt to form an objective view of UML and its prospects.The members of panel have been working closely with UhL in many different roles, including that of UML language designer, end-user, consultant, CASE tool expert, and object-oriented methodologist. The discussion will focus on how LJML matches up in practice against one of its original. raisons d'etre as the language of blueprints for software.Specific issues to be addressed include:• What is advantage of UML over existing OOA/D notations?• Can UML be used on real projects today?• Is language sufficiently simple, and well-enough defined, to become de facto standard?• Will UML lead to improved OOA/D methods and CASE tools?• What is importance of meta-model in UML?


title: Changing the Engine of the Car? While Driving 60 Miles an Hour! (Panel)

authors:
James Coplien
Luke Hohmann
Norman L. Kerth
John Rae-Grant
Eileen Strider

abstract: Most software development projects don't practice what is usually considered "proper" software engineering practices: well-documented, traceable requirements do not exist, formal inspections are non-existent, analysis and design inodels are incomplete or not even done at all, and so forth. We know that many of these projects fail, and it is easy to blame the failure of the project on the lack of good software engineering practices ("If we only had well-documented requirements, a complete and thorough test plan, and formal schedules then we would have been successful!")But many projects that do not practice what many consider to be good software engineering practices succeed, and succeed famously. Examples include the startup introducing a revolutionary new product, the skunkworks project of an established firm that succeeds in changing the status quo, and selecting a mission critical application as the first OO application of a group just beginning to make the transition to the new technology.Gaining a deeper understanding of success and failure on software projects is absolutely essential for the continued maturation of our industry, and object technology in particular.


title: A Framework for Scalbale Dissemination-Based Systems

authors:
Michael J. Franklin
Stanley B. Zdonik

abstract: The dramatic improvements in global interconnectivity due to intranets, extranets, and the Internet has led to an explosion in the number and variety of new data-intensive applications. Along with the proliferation of these new applications have come increased problems of scale. This is demonstrated by frequent delays and service, disruptions when accessing networked data sources. Recently, push-based techniques have been proposed as a solution to scalability problems for distributed applications. This paper argues that push indeed has its place, but that it is just one aspect of a much larger design space for distributed information systems. We propose the notion of a Dissemination-Based Information System (DBIS) which integrates a variety of data delivery mechanisms and information broker hierarchies. We discuss the properties of such systems and provide some insight into the architectural imperatives that will influence their design. The DBIS framework can serve as the basis for development of a toolkit for constructing distributed information systems that better match the technology they employ to the characteristics of the applications they are intended to support.


title: Beyond the Hype: Do Patterns and Frameworks Reduce Discovery Costs? (Panel)

authors:
Steven Fraser
Kent L. Beck
Grady Booch
James Coplien
Ralph E. Johnson
Bill Opdyke

abstract: Patterns and frameworks are two approaches to the development of both new and evolving software systems. An implicit hypothesis is that are reduced by leveraging knowledge previously collected, analyzed, organized, and packaged. Discovery (or getting started costs) include both the costs of understanding the problem to be solved and the cost of understanding the tools, methods, existing software, etc. For large, multi-year development projects in industries such as defense or telecommunications, discovery costs can dominate the overall cost (and risk) of software development.This panel will share its experience and perspectives with the audience with a discussion initiated by the following questions:• Have patterns and frameworks really delivered on their claims for reducing discovery costs? Can current best-practices be characterized as meaningful or marginal (what are the measures)?• What are the discovery cost factors where frameworks and patterns appear to deliver the biggest bang for the buck?• While mature pattern languages and frameworks may reduce the learning curve, they do not, eliminate it. How much of a learning curve is required to develop a sufficient shared context with the authors of a set of patterns or a framework?