ECOOP '93 - Object-Oriented Programming: 7th European Conference, Kaiserslautern, Germany, July 26-30, 1993. Proceedings (Lecture Notes in Computer Science, 707)

✍ Scribed by Oscar M. Nierstrasz (editor)

• Publisher: Springer
• Year: 1993
• Tongue: English
• Leaves: 540
• Edition: 1993
• Category: Library

✦ Synopsis

It is now more than twenty-five years since object-oriented programming was “inve- ed” (actually, more than thirty years since work on Simula started), but, by all accounts, it would appear as if object-oriented technology has only been “discovered” in the past ten years! When the first European Conference on Object-Oriented Programming was held in Paris in 1987, I think it was generally assumed that Object-Oriented Progr- ming, like Structured Programming, would quickly enter the vernacular, and that a c- ference on the subject would rapidly become superfluous. On the contrary, the range and impact of object-oriented approaches and methods continues to expand, and, - spite the inevitable oversell and hype, object-oriented technology has reached a level of scientific maturity that few could have foreseen ten years ago. Object-oriented technology also cuts across scientific cultural boundaries like p- haps no other field of computer science, as object-oriented concepts can be applied to virtually all the other areas and affect virtually all aspects of the software life cycle. (So, in retrospect, emphasizing just Programming in the name of the conference was perhaps somewhat short-sighted, but at least the acronym is pronounceable and easy to rem- ber!) This year’s ECOOP attracted 146 submissions from around the world - making the selection process even tougher than usual. The selected papers range in topic from programming language and database issues to analysis and design and reuse, and from experience reports to theoretical contributions.

✦ Table of Contents

Front matter
ECOOP '93 -Obj ect-OrientedProgramming
Preface
Organising Committee
Sponsor
Co-Sponsoring and Contributing Organisations
Programme Committee
Referees
Contents
Chapter 1
References
Chapter 2
1 Introduction
2 The Reuse Situation
2.1 The Color-Mixer Project
2.2 The Library Project
3 Reuse of Uses
3.1 Reusing Pieces of an Example
3.2 Reusing an Application Framework
4 The Reuse Programming Process
4.1 Getting Something to Work With
4.2 Debugging into Existence
5 Summary and Implications
5.1 Scope of Active Reuse
5.2 Consequences of Active Reuse
5.3 Training and Tools for Active Reuse
Acknowledgements
References
Chapter 3
1 Introduction
2 Swaps
2.1 The Swap Product
2.2 Current Situation
2.3 Towards better Solutions
3 The Architecture of the Calculation Engine Framework
3.1 The Key Abstractions
3.1.1 Instrument
3.1.2 Discount function
3.2 Scenarios
3.2.1 Discount Factor Calculation
3.2.2 Cash Flow Generation
4 Experience
Acknowledgements
References
Chapter 4
1 Introduction
2 Assumptions
3 The Problem: Inconsistent Components
4 Integration Using Composition
4.1 Problems with Wrappers
4.2 Even more Problems with Wrappers
5 Integration Using Typing Mechanisms
5.1 Implicit Subtyping
5.2 Multiple Subtyping
5.3 Factory Objects
5.4 Multimethods
6 Discussion
7 Towards a solution
7.1 Type Adaptation
7.2 Extension Hierarchies
7.3 Other Related Work
8 Conclusions
References
Chapter 5
1. Introduction
1.1. An Example
1.2. Characteristics of Distributed Object-Oriented Computation
1.3. Gaggles
2. Relationship with other work
2.1. Group Communication amongst Objects
2.2. ISIS Process Groups
2.3. Replicated Objects in Emerald
2.4. Fragmented Objects
3. Using Gaggles
3.1. Usage Paradigms
A Gaggle of Independent Objects.
The Consistent Gaggle.
A Gaggle of Workers.
Hiding Object Identity.
3.2. Some Applications of Gaggles
Accessing a Name Service
Causally Consistent Name Service.
Mail dispatch.
One Object, Many R6les.
Type Restriction.
4. The Design of Gaggles
4.1. Syntax
4.2. Semantics
4.3. Other Language Constructs
4.4. Semantics of Gaggle Invocation
4.5. Failure Semantics
4.6. Ownership vs. Multiple Interfaces
4.7. Types
4.8. Removal and Enumeration
4.9. Gaggles as members of Gaggles
5. Implementation Considerations
5.1. Algorithms for Finding Objects
The Broadcast Algorithm.
The Hermes Algorithm.
Modifying the finding algorithms for Gaggles.
Stable Storage.
The addMember operation.
5.2. The Emerald implementation of Gaggles
6. Current Status
Acknowledgements
References
Chapter 6
1 Introduction
1.1 Procedure Oriented Interoperability
1.2 Object Oriented Interoperability
2 Overview of Object Oriented Interoperability
2.1 Terminology
2.2 Type Matching
2.2.1 Towards a solution to the Type Matching problem
2.2.2 Type Relations
2.2.3 To Type-Match or not to Type-Match?
2.3 Object Mapping
2.3.1 Inter-Classes and Inter-Objects
2.3.2 Dynamic Support of the Object Mapping
3 Prototype Implementation
3.1 Type Matching on the Hybrid cell
3.1.1 Type Relations
Equivalent and Translated types.
Type Matched types.
3.2 Binding of Operations
3.2.1 Parameters phase
Migrated parameters
Mapped Parameters
Multi-type mapped parameters
3.2.2 Interface adaption
3.3 Object Mapping
4 Conclusions and issues to be studied
References
Annex I: Type Matching Programming Language.
Annex 11: Type Match definition example
Chapter 7
1 Introduction
2 Object Format
3 Communication
4 Remote Invocation and Parameter Passing
5 Performance
6 Related Work
7 Conclusion
Acknowledgments
References
Chapter 8
1 Introduction
2 Model of Computation
3 The Meaning of Subtype
3.1 The Basic Idea
3.2 Formal Definition
3.3 Discussion
3.4 Applying the Definition of Subtyping as a Checklist
4 Type Hierarchies
4.1 Extension Subtypes
4.2 Constrained Subtypes
5 Related Work
6 Conclusions
Acknowledgments
References
Chapter 9
Abstract
1. Introduction
2. Motivations
2.1 Strong Type-Checking
2.2 Order-Sorted and Heterogeneous Sets
2.3 Optimization and Parametric Polymorphism
3. Background: The LAURE Type System
3.1 A Set-Based Type System
3.2 Features and Polymethods
3.3 Second-Order Types
4. Informal Description of Polymethods
4.1 Attaching Methods to Types
4.2 Attaching Type Expression to Methods
4.3 Second-Order Type Inference
5. Using Polymethods
5.1 Framework for Inheritance Conflict Resolution
5.2 Type Inference and Abstract Interpretation
5.3 Lazy Abstract Interpretation with A(T)
5.4 Application to New Polymethod Definitions
6. Application to Common Problems
6.1 The Min Method
6.2 List Operations and Polymethods
6.3 Stacks
6.4 Comparison with Related Works
7. Conclusion
Acknowledgments
References
Chapter 10
1 Introduction
2 Motivation with Examples
2.1 Predicative Sets
2.2 Constraints
3 Formal Language Features
3.1 Cardelli Type Theory
3.2 Adding Predicates - The Logical Formalism
3.3 Adding Powertypes and Sets
4 Mapping Higher-order 00 Concepts
4.1 Introductory Remarks
4.2 Three-level Methodology
4.3 Modelling of TM concepts in FM.
5 Conclusions and future work
6 Acknowledgements
References
Chapter 11
1 Introduction
2 Background
2.1 What is OSI Network Management?
2.2 A Crash Course on the OSI Reference Model
2.3 Application-layer Message Development
3 OSI Management Architecture
3.1 OSI Managed-object Model
3.1.1 Managed objects
3.1.2 Managed-object Structuring
3.1.3
Managed Relationships
3.2 Managed-object Services
3.2.1 Managed-object Life Cycle
3.2.2 Managed-object Specification
3.2.3 Carriage Protocol
3.3 Summary of OSI Network Management Architecture
3.4 Managed-object Compatibility
4 Next-generation Network Management Standards
4.1 Requirements
4.2 Distributed Management Architecture
4.3 Inter-network Management
4.4 Interoperability Evolution
5 Conclusions
References
Chapter 12
1. Introduction
2. Mixin-based Inheritance
3. Mixins as Attributes
3.1 Applicability of Mixins
3.2 Mixins and Encapsulated Inheritance
4. Mixin-based Inheritance in Agora
4.1 Some Agora Syntax
4.2 Mixins & Methods
5. Introducing Block Structure in Object-Oriented Languages
5.1 An Example of Mixin Nesting in Agora
6. Classes as Attributes, Class Nesting Versus Mixin Nesting
7. Mixin Methods
8. Status, Evaluation, and Future Work
9. Related Work
10. Conclusion
11. Acknowledgments
12. References
Chapter 13
1 Introduction
2 Rewriting Logic as a Semantic Framework for Concurrent Object-Oriented Programming
3 Maude’s Object-Oriented Modules and their Translation into Rewrite Theories
4 Class Inheritance
5 Module Inheritance and Message Specialization
6 The Cheshire Cat
7 Implementation Issues
7.1 Simple Maude as a Machine-Independent Parallel Language
7.2 MIMD, SIMD, and MIMD/SIMD Implementations
8 Concluding Remarks
Acknowledgements
References
Chapter 14
1 Introduction
2 Type Constraints
2.1 Constraint-Based Analysis
2.2 Types and Type Variables
2.3 Constraints for SELF
2.4 Code Duplication
2.5 Constraint Solving
3 Examples
3.1 The Tangled Web: Simple Arithmetic
3.2 Browsing Programs: Towers of Hanoi
3.3 Mastering Dynamic Inheritance: Binary Search Trees
4 Algorithm and Implementation
5 Conclusion
References
Chapter 15
1 Introduction
2 Cecil
2.1 Objects
2.2 Methods
2.3 Fields
2.4 Closures
3 Predicate Objects
3.1 Predicate Objects
3.2 Predicate Objects and Methods
3.3 Predicate Objects and Inheritance
3.4 Dynamic Reclassification of Objects
3.5 Predicate Objects and Fields
3.6 Predicates on Methods
3.7 Static Type Checking
3.8 Implementation Strategies
4 Additional Examples
4.1 Pattern Matching-Style Functions
4.2 Attributes of People
4.3 Squares, Rectangles, and Polygons
4.4 Mutable Binary Trees
5 Related Work
5.1 Value-Based Dispatching in Other Object-Orlented Langu
ages
5.2 Sets and Polymethods in LAURE
5.3 Classifiers in Kea
5.4 Term Classification
5.5 Dynamic Inheritance in SELF and Garnet
5.6 Other Related Work
6 Conclusion
Acknowledgments
References
Chapter 16
ABSTRACT
1. Introduction
2. Motivating Example and Data Model
2.1. Schema Graph
2.2. Objects and the Object Graph
3. An Overview of TOOA
3.1. Assumptions
3.2. Overview of the Operators
4. Object Level Operators
4.1. Objects with Tuple Values
4.2. Set and List Structures
4.3. Time Sequence Structures
4.4. Update Operators
5. Schema Level Operators
6. Summary and Future Work
REFERENCES
Chapter 17
1 Introduction
2 Basic Framework
2.1 Time in Distributed Computing
2.2 Extensions of CCS
3 Definition
3.1 Time Domain
3.2 Notation and Syntax
3.3 Semantics
Expressions on Local Time
Expressions on Global Time
3.4 Examples on Description of Distributed Objects
4 Bisimulation Based on Local Time
Preorder on Clocks
Examples on Verification of Distributed Objects
5 Conclusion
Acknowledgements
References
Chapter 18
1 Motivation
2 Basic Concepts and Notation
3 Coordinating Groups of Objects
4 Customized Access Schemes
5 Related Work
6 Discussion
Acknowledgments
References
Chapter 19
1. Introduction
2. Programming in PANDA
2.1 Thread Package
2.2 Distribution
Providing Distributed Shared Memory
Implementation of the DSM Mechanism
Providing Thread Mobility
2.3 Persistent Objects
2.4 Garbage Collection
Design Rationales
Language-Based Implementation
Potential Problems
3. System Architecture
Object-Oriented System Design
Main Components
4. status
Performance
5. Conclusions and Future Work
Acknowledgments
References
Chapter 20
1 Introduction
2 Programming Massively Parallel Architectures with Sequential Object Oriented Languages
2.1 Embedding data parallelism in an OOL
2.2 The Eiffel Parallel Execution Environment
3 Towards reusing software components for parallelism
3.1 Classical approach of reuse
3.2 A key towards reuse in OOLi ;,nheritance
3.3 Reusing sequential code for a parallel execution
4 A realistic example
4.1 Generality of the method
4.2 Customized walks
4.3 Reusing the class Matrix to build a class DistributedMatrix
4.4 A comment on the efficiency of this approach
4.5 Implementation comments and results
4.6 Problems and limitations
5 Coiiclusioii
References
Chapter 21
1 Introduction
2 Design Patterns
3 Categorizing Design Patterns
3.1 Class Jurisdiction
3.2 Object Jurisdiction
3.3 Compound Jurisdiction
4 Experience with Design Patterns
4.1 ET+ + S wapsManager
4.2 QOCA: A Constraint Solving Toolkit
4.3 Summary of Observations
5 Related Work
6 Conclusion
7 Acknowledgements
References
A Catalog Overview
ABSTRACT FACTORY
STRATEGY
WRAPPE
Chapter 22
Introduction
2 ObjChart Notations
Object
Relations
State Machines
Sequence
Object Decomposition
Model Execution
3 Behavioral Semantics of ObjChart Objects
3.1 The Equational Framework
3.2 Object Subsumption
3.3 Semantics of Contracts
4 Specification Structuring and Reasoning
4.1 Modeling of Reactive Systems in ObjChart
4.2 Reasoning with ObjChart Models
4.3 Orthogonality of Functional Invariants from Causality Chain
5 Comparison
5.1 Statechart
5.2 Objectchart
5.3 OMT
6 Conclusion
Acknowledgement
References
Chapter 23
1 Introduction
2 Requirements Engineering of Composite Systems
2.1 Requirements Engineering vs. Software Engineering
2.2 The Four Tasks of Requirements Engineering
2.3 Properties of R.E. Languages
2.4 Composite Systems
3 ALBERT: the Language
3.1 Models Q  a specification
3.2 Language Constructs
3.3 Declarations
3.4 Constraints
4 The Elaboration of the Requirements Document
4.1 The Elaboration Process
4.2 Identifying Agents Responsibilities
4.3 Reasoning on Agents Responsibilities
5 Conclusion
References
Chapter 24
1 Introduction
2 Open C++: A Simple MOP for C++
2.1 Base-Level Directives
2.2 Metaobject Protocol
2.3 Why Meta? Pros and Cons
3 Object Communities - An Additional MOP for Distributed Computing
3.1 Background Problem
3.2 Overview of Object Communities
3.3 MOP of Object Communities
4 Examples of Method-Call Extension
5 Overheads due to having a Meta Level
6 Related Work
7 Conclusion
Acknowledgments
References
Chapter 25
Abstract
Introduction
Related Work
Architecture
Motivation
The MetaFlex Parser
MetaFlex Source Code Generation
Metaclass Specification Language
Case Study: Scripting Enabled Applications
MetaFlex Tool Implementation for the Scripting Application
Compile-time Description
Run-time Description
Evaluation
Specifying MetacIasses
Type Checking
Name Overloading
MetaFlex Maintenance and Performance
Metaclass Specification Recommendation
Conclusions
Acknowledgments
References
Chapter 26
1 Background
2 Mike Banahan
3 Boris Magnusson
Back matter
Author Index