ECOOP 2001 - Object-Oriented Programming: 15th European Conference, Budapest, Hungary, June 18-22, 2001, Proceedings (Lecture Notes in Computer Science, 2072)

✍ Scribed by Jorgen Lindskov Knudsen

• Publisher: Springer
• Year: 2001
• Tongue: English
• Leaves: 442
• Category: Library

✦ Synopsis

This book constitutes the refereed proceedings of the 15th European Conference on Object-Oriented Programming, ECOOP 2001, held in Budapest, Hungary, in June 2001.
The 18 revised full papers presented together with one invited paper were carefully reviewed and selected from 108 submissions. The book is organized in topical sections on sharing and encapsulation, type inference and static analysis, language design, implementation techniques, reflection and concurrency, and testing and design.

✦ Table of Contents

ECOOP 2001 –Object-Oriented Programming
Preface
Organization
Program Committee
Referees
Contents
Language, Objects, and Intentionality
Capabilities for Sharing: A Generalisation of Uniqueness and Read-Only
Introduction
Annotations for Controlling References
Capabilities for Sharing
Access Rights
Base Rights
Exclusive Rights
The Ownership Right
Composing Access Rights
Semantics of Capabilities
Evaluation
Execution Gets Stuck Only when Access Rights Missing
Policy and Mechanism
Example: Uniqueness
Example: Borrowed Pointers
Example: Read-Only
Procedures and Modular Static Checking
Ownership
Type Systems
Discussion
Object Rights vs. Capability Rights
Memory Management
Concurrency
Access Rights Are Single-Level
Implementations
Access Rights for Parts of Objects
Other Rights
Related Work
Conclusion
References
Sealing, Encapsulation, and Mutability
Introduction
Taxonomy of Fields
Sealing and Encapsulation
Data Set
Sealing and the OO Type Analysis Problem
Sealing and Mutability Analysis
Discussion
References
Simple Ownership Types for Object Containment
Introduction
Object Calculus with Contexts
The Object Calculus
Extending the Calculus with Contexts
Syntax for an Object Calculus with Ownership
Examples
Formal Presentation of Ownership Types
Permissions and Containment
The Type System
Dynamic Semantics and Properties
An Operational Semantics
Key Properties
The Containment Invariant
Related Work
Conclusion
References
Distinctness and Sharing Domains for Static Analysis of Java Programs
Introduction
Domains and Operations
Concrete (Standard)Domain
Abstract Domains
Orderings
Upper Bounds
Convergence
Abstract Assignments
Application to Program Specialization
Related Work
Static Analysis of Object-Oriented Programs
Abstract Interpretation of Logic Programs
Pointer and Sharing Analysis
Static Detection of Errors
Program Specialization
Future Work
References
Precise Constraint-Based Type Inference for Java
Introduction
A Framework for Object-Oriented Constraint Inference
The Types
Constraint Generation
Computation of the Closure
Data Polymorphic Analysis
Motivation
The DCPA Algorithm
Implementation
Java Language Issues
Optimizations
Experimental Results
Related Work
References
CCC: User-Defined Object Structure in C
Introduction
CCC Overview
Conditionally Defined Classes
Class Types
Examples
Generating Dispatch Functions
Discussion
Combining with User-Level Classes
Overlapped Conditions
Condition Reuse
Non-OO Application
Multi-method Dispatching
Method Search Direction
C++ as Target Language
CCC Implementation
Related Work
Conclusion
References
Fickle : Dynamic Object Re-classification
Introduction
An Example
The Language ensuremath {cal F}{it {ickle}}
Syntax
Operational Semantics
Typing
Related Work
Design Alternatives
Conclusions
References
Appendix
Scripting .NET Using Mondrian
Introduction
Mondrian
History and Context
Functions and Expressions
Types
Multi-choice Selection and Pattern Matching
Namespaces
Commands
Exceptions
Handling Exceptions
Example
Concurrency
Threads in Mondrian
Inter-thread Synchronization and Communication
Other IPC Methods
Implementation
The Representation of Values and Functions
Function Arguments and Partial Applications
Just in Time" Computations Interop Calling {C$^sharp $} from Mondrian Calling Mondrian from {C$^sharp $} and Other .NET Languages References A Quasi Optimal Bit-Vector Encoding of Tree Hierarchies. Application to Efficient Type Inclusion Tests Introduction Previous Works The Encoding Algorithm Dichotomic Encodings The Algorithm Results Theoretical Results Practical Results Conclusion References On the Usefulness of Liveness for Garbage Collection and Leak Detection 2 Background 3 Motivation 4 Related Work 1 Introduction 5 Methodology Approach for Type Accuracy Approach for Liveness Accuracy Levels in This Paper Measurement Methodology Limitations Benchmarks 6 Results Usefulness of Liveness Liveness versus Type Accuracy Strength of Liveness Analysis Effectiveness in Finding Leaks Validation of Our Methodology Implications for Leak Detection and GC Summary of Results 7 Experiences 8 Future Work 9 Conclusions Acknowledge References Concurrent Cycle Collection in Reference Counted Systems Introduction Previous Work on Cycle Collection Synchronous Cycle Collection Pseudocode and Explanation Acyclic Data Types Concurrent Cycle Collection Two Phase Cycle Collection Liveness: Finding Cycles to Collect Safety: Collecting Cycles Concurrently Pseudocode and Explanation Proofs The Abstract Graph Safety: Proof of Correctness Liveness: Proof of Correctness Measurements Benchmarks Cycle Collection Related Work on Concurrent Collection Conclusions Acknowledgements References A Bytecode Translator for Distributed Execution ofLegacy'' Java Software
Introduction
Addistant
Design Goal
Remote Reference
Object Allocation
Bytecode Delivery
Implementation Issues
Single System Image
Bytecode Modification
Distributed Swing Applications
Policy File
Performance Measurement
Related Work
Transparent Distribution
Remote Display
Aspect-Oriented Programming
Conclusion
Acknowlegement
References
Reflections on MOPs, Components, and Java Security
Introduction
Security, MOPs, and Components
The Security Architecture of Java
Meta-programming and Java
Component-Based Architecture and MOPs
Combining Permission Sets with Reflection
Compile-Time MOPs
Load-Time MOPs
VM-Based Runtime MOPs
Proxy-Based Runtime MOPs
texttt {doPrivileged} and Summary
Related Work: MOP-Based Security Enforcement
Conclusion
References
TheOptimisticReadersTransformation
Introduction
Definitions and Overview
Refinement
Memory Model
Aborts
Special Situations
Nested Reads
``Usually Read'' Methods
Multi-partition Objects
Single Word Write
A Toolkit
Experimental Results
Background and Methodology
Results
Related Work
Discussion
References
Invited Talk: People and the Limits of Methodology
Family Polymorphism
Introduction
We Need Class Families
Handling Graphs with Traditional Polymorphism
The Na{"i }ve Approach
Working Out Safety
The Scope of This Problem
Handling Graphs with Family Polymorphism
Revisiting the Problems
Revisiting the Alternative
Aspects of the textsf {gbeta}{} Static Analysis
Related Work
Conclusion
References
An Overview of AspectJ
Introduction
Basic Design Assumptions
The Language
Join Point Model
Pointcut Designators
Advice
Aspects
Aspect Precedence
Pointcut Parameters
Reflective Access to Join Point
Inheritance and Overriding of Advice and Pointcuts
Property-Based Crosscutting
Implementation
Compilation of Advice Bodies
Corresponding Method
Dynamic Dispatch
Tool Support
Understanding Crosscutting Structure
Modular, Concise, and Explicit
The Role of IDE Technology
Related Work
Other Work in AOP
Multi-dimensional Separation of Concerns
Reflection
Object-Oriented Programming
Other Work
Future Work
Summary
Acknowledgements
References
True Modules for Java-like Languages
Introduction
A True Module Language for Java
Basic Modules
Module Expressions
An Open Issue: Extending Imported Classes
Type-Checking Modules in textsc {JavaMod}
A Compiler for textsc {JavaMod}
A Type System for textsc {JavaMod}
Related Work
Conclusion
References
Selecting an Efficient OO Integration Testing Strategy: An Experimental Comparison of Actual Strategies
Introduction
Stub Minimization and Testing Resource Allocation
Stub Minimization
Testing Resource Allocation
From UML to Test Dependence Graph (TDG)
Integration Strategies
Kung and al.’s Strategy [10]
Tai-Daniels’ Strategy [4]
Triskell Strategy
Using Genetic Algorithms for Stub Minimization
Case Studies
Comparison of Algorithms and Comments
Conclusion
Acknowledgments
References
Quality and Understandability of Use Case Models
1 Introduction
2 Use Case Modelling
2.1 Minor Guidelines
2.2 Template Guidelines
2.3 Style Guidelines
2.4 Recommendations for Use Case Models
3 The Experiment
3.1 Experiment Participants
3.2 Training
3.3 Procedure of Experiment
3.4 Marking Scheme
3.5 Hypotheses
4 Results
4.1 Assessment of Understandability
4.2 Assessment of Usefulness – Hypothesis H3
4.3 Assessment of Quality
5 Discussion
5.1 Minor Guidelines
5.2 Template Guidelines
5.3 Style Guidelines
6 Threats to Validity
6.1 Students as Subjects
6.2 Complexity of the Task
6.3 Participants Both as Customers and Developers
6.4 Motivation
6.5 Dependence on Informal Specifications
6.6 Experience
6.7 Questionnaires
7 Ethical Considerations
8 Conclusions and Future Work
Acknowledgements
References
Appendix A
Appendix B
Description – System A
Description – System B
Appendix C
Questions for System A:
Questions for System B:
Author Index