ECOOP - Object-Oriented Programming: 21th European Conference, Berlin, Germany, July 30 - August 3, 2007, Proceedings

✍ Scribed by Erik Ernst (editor)

• Publisher: Springer
• Year: 2007
• Tongue: English
• Leaves: 637
• Series: Lecture Notes in Computer Science; 4609
• Category: Library

✦ Synopsis

This book constitutes the refereed proceedings of the 21st European Conference on Object-Oriented Programming, ECOOP 2007, held in Berlin, Germany in July/August 2007. The 25 revised full papers, presented together with 3 invited talks were carefully reviewed and selected from a total of 135 final submissions. The papers are organized in topical sections on types, runtime implementation, empirical studies, programs and predicates, language design, inheritance and derivation, aspects, as well as language about language.

✦ Table of Contents

Title Page
Preface
Organization
Table of Contents
Erlang – Software for a Concurrent World
Gradual Typing for Objects
Introduction
A Programmer’s View of Gradual Typing
An Implementor’s View of Gradual Typing
Combining Gradual Typing and Subtyping
A Gradually Typed Object Calculus
A Semantics for $\mathbf{Ob}^{?}{<:}$
The Cast Insertion Translation
Operational Semantics of $\mathbf{Ob}^{\langle\cdot\rangle}{<:}$
Type Safety of $\mathbf{Ob}^?_{<:}$
Progress
Preservation
Type Safety
Related Work
Conclusion and Future Work
References
Generic Universe Types
Introduction
MainConcepts
Static Checking
Programming Language
Viewpoint Adaptation
Subclassing and Subtyping
Lookup Functions
Well-Formedness
Type Rules
Runtime Model
Heap Model
Lookup Functions
Well-Formedness
Operational Semantics
Properties
Conclusion
References
Declarative Object Identity Using Relation Types
Introduction
Overview of RJ
Java’s Equality Contract
Examples
Revised Equality Contract
Relation Types
Lifetime Management and Namespaces
A Core Calculus for RJ
Syntax
Semantics
The RJ-HC Language
Implementation and Evaluation
Implementation
Case Study: $javacup$
Other Benchmarks
Related Work
Summary and Future Work
References
Object-Relative Addressing: Compressed Pointers in 64-Bit Java Virtual Machines
Introduction
Object Pointer Compression: PriorWork
Object-Relative Addressing
Basic Idea
Decompressing Pointers
Compressing Pointers
Null Pointer Representation
Managing the LAT
Implications to Copying Garbage Collectors
Discussion
Implications for Memory Management
Experimental Setup
Jikes RVM
Benchmarks
Hardware Platform
Statistical Analysis
Evaluation
Performance
Cache Hierarchy Performance
Memory Usage
Related Work
Java ProgramMemory Characterization
Pointer Compression
Object Header Compression
Conclusion
References
Generational Real-Time Garbage Collection A Three-Part Invention for Young Objects
Introduction
Metronome Overview
Time Based Scheduling
Collector Design
Real-Time Generational Collection
Tri-partite Nursery
Incremental Generational Collection
Mature/Nursery Interaction
AnalyticalModel
Definitions
Steady-State Assumption and Time Conversion
Bounds for Non-generational Metronome Collectors
Bounds for Our Generational Collector
Comparison with Syncopation
Experimental Evaluation
Generational vs. Non-generational Comparison
Dynamic Nursery Size
Parameterization Studies
Startup vs. Steady State Behavior
Related Work
Conclusion
References
AS-GC: An Efficient Generational Garbage Collector for Java Application Servers
Introduction
ThisWork
Why Design a Garbage Collector for Application Servers?
Basic Characteristics of Application Servers
An Experiment to Evaluate Lifespans of Objects in Server Applications
A Generational Collector for Application Servers (AS-GC)
Defining Key Objects
Dynamic Objects Segregation
Local and Remote Nurseries
Tracking Inter-nursery References
Experimental Environment
Application Server andWorkload Driver
Experimental Platforms
Results and Analysis
Garbage Collection Behaviors
Heap Utilization
Throughput
Ability to Handle HeavierWorkload
Discussion
Lifespan Interference
Region-BasedMemory Management
Applicability Study
Related Work
Conclusion
References
Exception Handling: A Field Study in Java and .NET
Introduction
Related Work
Workbench
Methodology
Results
Error Handling Code in Applications
Code in Exception Handlers
Exception Handler Argument Classes
Handled Exceptions
Making Exception Handling Work
Conclusion
References
On the Impact of Aspectual Decompositions on Design Stability: An Empirical Study
Introduction
Experimental Settings
Target System Selection
Study Phases and Change Scenarios
Health Watcher System
The Object-Oriented Design
The Aspect-Oriented Design
Change Scenarios
Modularity Analysis
Quantifying Initial Modularity
Quantifying Modularity Stability
Change Impact Analysis
Impact of the Change Nature
Overall Stability Measurements
Concern Interaction Analysis
Concern-Interaction Categories
Concern Interactions in the Base Versions
Scalability of Aspectual Decompositions
Discussions
Observing Ripple Effects
Architecture Stability Analysis
Related Work and Study Constraints
Related Work
Study Constraints
Concluding Remarks
References
An Accidental Simula User
Validity Invariants and Effects
Introduction
A Model for Object Validity
The Validity Contract $\modelIE$
Validity Subcontract for Nested Behaviours
Object Invariants and Dependency Structure
Oval: A Language with Ownership-Based Validity
Ownership Types and Effect Encapsulation
Overview of Oval
Oval by Example
Abstract Contexts and Mutability from Top to Bot
The Oval Type System
Syntax and Static Semantics
Dynamic Semantics and Properties
Discussion and Related Work
Boogie and Universes
Ownership Type Systems
Read-Only Systems
Conclusion
References
Non-null References by Default in Java: Alleviating the Nullity Annotation Burden
Introduction
Study
Hypothesis
Case Study Subjects
Procedure
Verification and Validation of Annotations
Metrics
Statistics Tool
Threats to Validity
Study Results
Related Work: Languages and Nullity
Languages Without Pointer Types
Imperative Languages with Pointer Types
Object-Oriented Languages (Non-Java)
Java Support for Non-null
Summary
Non-null by Default in Java
An Implementation of Non-null by Default: Eclipse JML JDT
Backwards Compatibility, and Migration to the New Default
Helping Automated Annotation Assistants Too
Conclusion
References
Efficiently Generating Structurally Complex Inputs with Thousands of Objects
Introduction
Example
Background: Forward Symbolic Execution
Algorithm
Egor: Random Graph Generator
Juzi++: Repair Framework
Dicos: Data Constraint Solver
Experiments
Methodology
Experimental Results
Scalability of Shekoosh
Discussion
Related Work
Specification-Based Linked Structure Generation
Error Recovery
Other Test Generation Techniques
Conclusions
References
Matching Objects with Patterns
Introduction
Standard Techniques
Object-Oriented Decomposition
Visitors
Type-Test/Type-Cast
Typecase
Case Classes
Extractors
Performance Evaluation
Parametricity
Conclusion
References
DirectFlow: A Domain-Specific Language for Information-Flow Systems
Introduction
Background
Why the Information-Flow Features Are Important
Information-Flow Features in Existing Systems
Comparison with Infopipes
The DirectFlow DSL
Language Overview and Syntax
The Context Condition
Compiling DirectFlow Modules
Principles of the Compilation Process
Mapping an Invalid DirectFlow Module to Objects
Inferring Polarity Configurations of DirectFlow Modules
Generating Code for Pipe Objects
TheDirectFlowFramework
Building a Pipeline
Composite Pipes
Related Work
Experiences
Conclusions and Future Work
References
A Relational Model of Object Collaborations and Its Use in Reasoning About Relationships
Introduction
Relations
Abstracting Object Collaborations
Terminology and Restrictions
Member Interposition
Problem Description and Solution
Formalization
Relationship Invariants
Structural Invariants
Value-Based Invariants
Discussion
References
Class Invariants
Invariant Preservation
Language Design Issues
Three Dimensions of Problem Decomposition
Language Definition
Creation, Addition, Removal, and Retrieval
Atomic Procedures
Related Work
Concluding Remarks
References
JavaGI: Generalized Interfaces for Java
Introduction
JavaGI by Examples
Example: Retroactive Interface Implementation
Example: Preserved Dynamic Dispatch
Example: Binary Methods
Example: Constrained Interface Implementations
Example: Static Interface Members
Example: Multi-headed Interfaces
Example: Bounded Existential Types
Translation to Java
Translating the Basics
Translating Retroactively Defined Methods
Translating Multi-headed Interfaces
Translating Bounded Existential Types
Interoperability with Java
AFormalTypeSystemforJavaGI
Syntax
Typing Judgments
Related Work
Conclusion and Future Work
References
Metaprogramming with Traits
Introduction
Background
A Design for Trait-Based Metaprogramming
Some Illustrative Examples
From No Parameters to Too Many?
A Formal Model: Meta-trait Java
Syntax
Translation to FGJ
Types in MTJ
Subtyping
Static Semantics: Expressions
Static Semantics: Member Declarations and Trait Expressions
Static Semantics: Classes and Traits
Soundness
Discussion
Related Work: Metaprogramming
Related Work: Type Systems
Related Work: Traits
Conclusion
References
Morphing: Safely Shaping a Class in the Image of Others
Introduction
Language Overview and Motivation
Language Basics
Applications
Type System: A Casual Discussion
Uniqueness of Declarations
Validity of References
Formalization
Syntax
Typing Judgments
Soundness
Discussion
Future Work and Conclusions
References
A Higher Abstraction Level Using First-Class Inheritance Relations
Introduction
Requirements Analysis
Requirements
Existing Reuse Mechanisms
The Component Relation
General Semantics
Renaming Parameters
First-Class Component Relations
The Subtyping Relation
Overriding and Merging Components
Reducing Hierarchy Dependencies
Evaluation
Complexity
The Banking Application
Case Study
Related Work
Future Work
Conclusion
References
Assuring Object-Oriented Architecture
MAO: Ownership and Effects for More Effective Reasoning About Aspects
Introduction
A Tale of Two Aspects
Control-Limited Advice
Concern Domains
Declaring Concern Domains
Using Concern Domains
Concern Domains and Aspects
Effect Declarations
Annotating Base Code
Effect Pointcut Designators
Formal Model: $MiniMAO_3$
The $MiniMAO_3$ Language
Operational Semantics
Static Semantics of $MiniMAO_3$
Meta-theory of $MiniMAO_3$
Evaluation
Case Study Data
Lessons Learned from the Case Study
Related Work
Conclusion
References
Joinpoint Inference from Behavioral Specification to Implementation
Introduction
Aspect-Oriented and Model-Driven Software Engineering
Model-Driven Software Engineering
System Modeling and Simulation
System Implementation and Verification
Model Translation and Code Generation
Weaving Aspects into Models
Motorola WEAVR: Weaving Aspects into Models
WEAVR Pointcuts Descriptors
Exception Handling Aspect
Recovery Aspect
Atomicity Aspect
Distributed Transaction Aspect
Discussion
Inference of Joinpoints from Specification to Implementation
Joinpoint Model and Selection
Discussion
Quantification over States and Triggers
Pointcut Composition
Isolation of Selections
Ordering of Joinpoints and Control Structures
Related Work
Conclusion
References
A Machine Model for Aspect-Oriented Programming
Introduction
Virtual Join Points
Delegation-Based AOP
Prerequisites
Introducing Aspects
Adding the Thread Dimension
Adding the Control Flow Dimension
Supporting Class-Based Languages
Introductions
Discussion and Summary
Semantics
The $\delta$ Calculus
Modifications and Extensions for Delegation-Based AOP
Example
Related Work
Join Points as Loci of Late Binding
Related Implementations
Summary and Future Work
References
A Staged Static Program Analysis to Improve the Performance of Runtime Monitoring
Introduction
Background
StagedAnalysis
Quick Check
Flow-Insensitive Consistent-Shadows Analysis
Flow-Sensitive Active-Shadows Analysis
Benchmarks
Execution Time of the Analysis
Related Work
Discussion and Future Work
References
Tracking Linear and Affine Resources with Java(X)
Introduction
Examples
JDOM Type Analysis
File Access
The Language \textsc{MiniJava(X)}
Syntax
Instances of \textsc{MiniJava(X)}
Dynamic Semantics
Static Semantics
Soundness
From MiniJava(X) to Java(X)
Polymorphism
Inheritance
Related Work
Conclusion
References
Attribute Grammar-Based Language Extensionsfor Java
Introduction
Sample Language Extensions
Extensible Java and Java Extension Specifications
Java Attribute Grammar Specification
Types and Subtyping in Java AG and Its Extensions
Using and Extending the Java Environment
Composition of Language Extensions
Composing Host Language and Extension Specifications
Issues in Composition
Parser-Context Based Lexical Disambiguation
Discussion
Ongoing Work and Conclusions
References
Metamodel Adaptation and Model Co-adaptation
Introduction
Background
Object-Oriented Refactoring
Grammar Engineering
Metamodel Evolution
Preservation Properties
Metamodels
Metamodel Relations
Semantics-Preservation
Instance-Preservation
Transformational Adaptation of MOF Compliant Metamodels
Overview
Construction and Destruction
Refactoring
Co-adaptation of Models
Transformation Patterns
Co-construction
Co-refactoring
Co-destruction
Applications
Metamodel Design
Metamodel Implementation
Metamodel Refinement
Metamodel Maintenance
Metamodel Recovery
Conclusion
References
Author Index