ECOOP 2012 -- Object-Oriented Programming
26th European Conference, Beijing, China, June 11-16, 2012, Proceedings
Published on 28. June 2012
XIV, 766 pages
978-3-642-31057-7 (ISBN)
Description
This book constitutes the refereed proceedings of the 26th European Conference on Object-Oriented Programming, ECOOP 2012, held in Beijing, China, in June 2012. The 27 revised full papers presented together with two keynote lectures were carefully reviewed and selected from a total of 140 submissions. The papers are organized in topical sections on extensibility, language evaluation, ownership and initialisation, language features, special-purpose analyses, javascript, hardcore theory, modularity, updates and interference, general-purpose analyses.
More details
Other editions
Additional editions
James Noble
ECOOP 2012 -- Object-Oriented Programming
26th European Conference, Beijing, China, June 11-16, 2012, Proceedings
Book
05/2012
1st Edition
Springer
€53.49
Shipment within 7-9 days
Content
- Title
- Preface
- Organization
- Table of Contents
- Keynote 1
- When Compilers Are Mirrors
- Extensibility
- Extensibility for the Masses Practical Extensibility with Object Algebras
- Introduction
- Background
- The Expression Problem
- Algebraic Signatures, F-Algebras, and Church Encodings
- Object Algebras
- Retroactive Interface Implementations
- Extensibility
- Internal Visitors as Object Algebras
- Adding New Variants and Updating Operations
- Subtyping Relations
- Multiple Types and Multi-sorted Object Algebras
- Multiple Types
- Evaluation of Statements: Algebras with Local State
- Modularity and Object Algebra Combinators
- Modular Combination of Algebra Interfaces
- Modular Combination of Algebras
- Combining Operations in Parallel
- Some Final Notes on Extensibility
- Case Study
- Related Work
- Conclusion
- References
- Extensions during Software Evolution: Do Objects Meet Their Promise?
- Introduction
- Background and Related Work
- Extensibility in OOP
- Related Work
- Experimental Setup
- Data Collection
- Data Processing
- Basic Statistics in Squeaksource
- Are Extensions Prevalent?
- Frequency of Extensions in Commits
- Frequency of Extensions in Class Hierarchies and Projects
- Executive Summary
- Comparing Data and Operation Extensions
- Frequency of Both Kinds of Events
- Quantifying the Difference between Kinds of Extension
- Relationship with Size of Hierarchies
- Executive Summary
- Extensions and Evolution
- Introducing Periods
- Evolution of the Ratio of Operation Extensions
- Executive Summary
- Is the Visitor Pattern a Suitable Solution?
- Prevalence of the Visitor Pattern
- How Are Visitors and Visitees Extended?
- Executive Summary
- Threats to Validity
- Construct Validity
- Internal Validity
- External Validity
- Conclusions
- References
- PQL: A Purely-Declarative Java Extension for Parallel Programming
- Introduction
- Language Illustration
- Language Constructs Overview
- Examples and Expressiveness
- Beyond Basics
- Implementation and Optimization
- Evaluation
- Benchmark Implementation Details
- Configuration
- Measurement Results
- Discussion
- Related Work
- Conclusions
- References
- Language Evaluation
- Is It Dangerous to Use Version Control Histories to Study Source Code Evolution?
- Introduction
- Research Methodology
- Unit of Code Change
- Research Questions
- How Much Code Evolution Data Is Not Stored in VCS?
- How Much Do Developers Intersperse Refactorings and Edits in the Same Commit?
- How Frequently Do Developers Fix Failing Tests by Changing the Test Itself?
- How Many Changes Are Committed to VCS without Being Tested?
- What Is the Temporal and Spacial Locality of Changes?
- Collecting Code Evolution Data
- AST Node Operations Inferencing Algorithm
- Threats to Validity
- Experimental Setup
- AST Node Operations Inferencing Algorithm
- Related Work
- Empirical Studies on Source Code Evolution
- Tools for Reconstructing Program Changes
- Tools for Fine-Grained Analysis of Code Evolution
- Conclusions
- References
- Evaluating the Design of the R Language
- Introduction
- An R Primer
- The Three Faces of R
- Functional
- Dynamic
- Object Oriented
- A Semantics for Core R
- Corpus Analysis
- The TraceR Framework
- A Corpus of R Code
- Evaluating the R Implementation
- Time
- Memory
- Evaluating the R Language Design
- Functional
- Dynamic
- Objects
- Experience
- Conclusions
- References
- McSAF: A Static Analysis Framework for MATLAB
- Introduction
- Overview
- Intermediate Representations and Simplifications
- High-Level AST
- Simplification Process
- Exposing Implicit Control Flow
- Simplifying Control Constructs
- Simplifying Single Statements and Expressions
- Dealing with Multiple Assignments
- Simplification Dependencies
- Simplification Frequencies
- Analysis Framework
- Traversal Mechanism
- Representations for Flow-Data
- Depth-First Analysis
- Structure-Based Analysis
- Analyses for Language Extensions
- Related Work
- Conclusions and Future Work
- References
- Ownerhsip and Initialisation
- Multiple Aggregate Entry Points for Ownership Types
- Introduction
- Ombudsmen-as-Dominators
- Clarkean Ownership Types
- Ombudsmen
- Typing Ombudsmen
- Components
- Iterators with Ombudsmen
- Staged Aggregate Construction
- Formalizing Ombudsmen
- Static Semantics
- Dynamic Semantics
- Meta Theory
- Related Work
- Discussion
- Ombudsmen and Reuse
- Ombudsmen and Ownership-Based Computational Effects
- Concluding Remarks
- References
- Inference and Checking of Object Ownership
- Introduction
- Unified Framework for Ownership Type Systems
- Framework and Unified Typing Rules
- Universe Types
- Ownership Types
- Heuristic Ranking over Typings
- Objective Function for Universe Types
- Objective Function for Ownership Types
- Maximal Typing
- Unified Type Inference
- Set-Based Solution
- Properties of the Set-Based Solution
- Inference of Universe Types
- Inference of Ownership Types
- Empirical Results
- Implementation
- Results
- Comparing Universe Types vs. Ownership Types
- Related Work
- Conclusion
- References
- Object Initialization in X10
- Introduction
- Initialization Pitfalls in Sequential Code
- The Crux of the Hardhat Design
- Initialization Pitfalls in Concurrent Code
- Initialization Pitfalls in Distributed X10 Code
- X10 Initialization Rules
- Constructors and Inheritance
- Dynamic Dispatch
- Exceptions
- Inner Classes
- Constraints and Default/Zero Values
- Properties and the Class Invariant
- Closures
- Generics and Structs
- Concurrent Programming and Initialization
- Distributed Programming and Initialization
- Read and Write of Fields
- Implementation
- Formalism: FX10
- Syntax
- Type System
- Effect System
- Reduction
- Results
- Related Work
- Conclusion
- References
- Keynote 2: Dahl-Nygaard Junior Award Winner
- Structured Aliasing
- Language Features
- Pause 'n' Play: Formalizing Asynchronous C
- Introduction
- Background: Async C Extensions in a Nutshell
- Example
- Formalization: Featherweight C 5.0
- Operational Semantics
- Correctness Properties
- Extensions
- Extension 1: Optimized, One-Shot Semantics
- Extension 2: The Awaitable Pattern
- Related Work
- Conclusions
- References
- Lightweight Polymorphic Effects
- Introduction
- Overview
- Effect-Polymorphic Function Types
- Programming with Effect-Polymorphic Functions
- An Extensible Framework for Multiple Effect Domains
- Formalization
- A Multi-domain Effect Lattice
- Subtyping
- Static Semantics
- Examples of Concrete Effect Domains
- Dynamic Semantics
- Effect Soundness
- Lightweight Polymorphic Effects in Scala
- Effect-Polymorphic Methods
- Effect Annotations in Scala
- Practical Experience
- Implementing Concrete Effect Domains
- Related Work
- Conclusions and Future Work
- References
- Cloud Types for Eventual Consistency
- Introduction
- Overview
- Cloud Integers and Cloud Arrays
- Revision Diagrams and Cloud Types
- Execution Model and Eventual Consistency
- Entities
- Stronger Consistency
- Syntax, Types, and Local Semantics
- Client Execution
- System Model and Distribution
- Flush
- Message Protocols and Server State
- Cloud Types
- A Fork-Join Automaton for blackCInt
- A Fork-Join Automaton for blackCString
- A Fork-Join Automata for the Complete State
- Implementation of |CSet|
- Related Work
- Conclusion
- References
- Special-Purpose Analyses
- Lock Inference in the Presence of Large Libraries
- Introduction
- General Approach
- Inferring Accesses
- IDE Transformers
- Graph Representation of Transformers
- Sparsity
- Native Code, Reflection and Dynamic Loading
- Inferring Locks
- Thread-Local Objects (TLA)
- Internal Objects (ILA)
- Single-Threaded Execution
- Multi-granularity Locks
- Other Optimisations
- Deadlock
- Implementation
- Summary Computation
- Reducing Space and Time Requirements
- Evaluation
- Soundness of Halpert et al
- Hello World
- Analysis Optimisations
- GNU Classpath
- HSQLDB
- Comparison with Halpert et al
- Related Work
- Conclusion and Future Work
- References
- An Analysis of the Mozilla Jetpack Extension Framework
- Introduction
- Background and Motivation
- Static Analysis of Jetpack Modules and Addons
- Stages of the Analysis
- Capability Flow: A Concrete Example
- Implementation
- Results
- Capability Leaks
- Capability Use
- Over-PrivilegedModules
- Related Work
- Conclusions
- References
- Smaller Footprint for Java Collections
- Introduction
- Compaction Techniques
- Hash Tables of the JRE
- Fused Buckets Hashing
- Squashed Buckets Hashing
- Virtual Entries
- Time Performance of Fused and Squashed Hashing
- Compaction of Balanced Binary Tree Nodes
- Further Research
- References
- JavaScript
- Enhancing JavaScript with Transactions
- Introduction
- Overview of Transcript
- Design of Transcript
- Components of an Iblock
- Hiding Sensitive Variables
- Security Assurances
- Trusted Computing Base
- Whitelisting for Host Policies
- Implementation in Firefox
- Enhancements to SpiderMonkey
- Supporting Speculative DOM Updates
- Conflict Detection
- The &script& Tag
- Evaluation
- Case Studies on Guest Benchmarks
- Fault Injection and Recovery
- Performance
- Complexity of Policies
- Related Work
- Conclusion
- References
- JavaScript as an Embedded DSL
- Introduction
- Introduction to LMS
- Example: A DSL Program and Its Generated JavaScript Code
- Walkthrough: Defining a DSL Component
- Gradual Typing for Interfacing with Existing APIs
- Typed APIs
- Casting and Optional Runtime Type Checks
- Scala Dynamic
- From Dynamic to Static
- Sharing Code between Client and Server
- Modularity Interlude
- Reification of Objects
- Functions
- Typed Object Literals
- Classes
- CPS Transformation for Asynchronous Code Patterns
- CPS in Scala
- CPS and Staging
- CPS for Suspendable Traversals
- Defining the Ajax API
- CPS for Parallelism
- Evaluation
- Conclusion
- References
- Correlation Tracking for Points-To Analysis of JavaScript
- Introduction
- Motivation
- JavaScript Objects and Functions
- Dynamic Property Accesses
- Field-Sensitive Points-To Analysis for JavaScript
- Correlation Tracking
- Example
- Implementing Correlation Tracking
- Evaluation
- Implementation
- Experimental Setup
- Results
- Other Languages
- Related Work
- Conclusions
- References
- Hardcore Theory
- Soundness of Object-Oriented Languages with Coinductive Big-Step Semantics
- Introduction
- Definition of the Language
- Background
- A Coinductive Semantics
- Type Systems
- Proof of Soundness
- Conclusion and Related Work
- References
- Static Sessional Dataflow
- Introduction
- Actors
- Dataflow Nets
- Type System
- Semantics
- Related Work
- Conclusions
- References
- Java Wildcards Meet Definition-Site Variance
- Introduction
- Background
- Definition-Site Variance
- Use-Site Variance
- A Comparison
- Combining Definition- and Use-Site Variance
- Insights for Combining Variances
- Realistic Complications
- VarJ
- Variance of a Type
- Variance of a Position
- Subtyping
- Typing and Wildcard Capture
- Type Soundness
- Discussion
- Related Work
- Conclusion
- References
- Modularity
- Constraint-Based Refactoring with Foresight
- Introduction
- Motivation
- Examples of the Foresight Problem
- Related Work
- A Brief Recap of Constraint-Based Refactoring
- Constraint Rules
- Conditional Constraints
- Specification of Refactorings
- Constraint Rule Rewriting
- Quantified Constraints
- A Constraint-Based Solution of the Foresight Problem
- Foresight with Constraint Rule Rewriting
- Foresight with Quantified Constraints
- Further Savings
- Basic Algorithm of Constraint-Based Refactoring with Foresight
- Implementation
- Evaluation
- Specification of PULL UP FIELD with Foresight
- Variants of PULL UP FIELD
- Experimental Setup and Results
- Conclusion
- References
- Magda: A New Language for Modularity
- Introduction
- Object-Oriented Languages: Limitations
- Limitations of Composition Mechanisms
- Non-modular Initialization Protocol
- The Magda Language
- Related Work
- Code Reuse Mechanisms
- Modularization of Constructors
- Dealing with Accidental Name Clashes
- Encapsulation in Magda
- Conclusions
- References
- Marco: Safe, Expressive Macros for Any Language
- Introduction
- Marco Overview
- The Marco Language
- The Marco Analysis Framework
- Checking Syntactic Well-Formedness
- Syntax Oracle Algorithm
- Syntax Oracle Example
- Discussion
- Context-Sensitive Syntax
- Context-Sensitive Syntax Examples
- Error Classification
- Iterative Syntax Oracles in Marco
- Checking Naming Discipline
- Free-Names Oracle
- Captured-Name Oracle
- Intentional Capture
- Dataflow Analysis
- Experimental Evaluation
- Methodology
- Expressiveness and Safety
- Language Scalability
- Related Work
- Language-Specific Safe Macro Systems
- Language-Agnostic Unsafe Macro Systems
- Using Messages from Black-Box Compilers
- Conclusion
- References
- Updates and Interference
- Practical Permissions for Race-Free Parallelism
- Introduction
- Fractional Read/Write Permissions
- Storable Permissions
- Gradual Permission Types in HJp
- Syntax and Semantics of Core HJp
- Static Semantics
- Operational Semantics
- Extensions
- Array-Based Parallelism
- Objects Guarded by Critical Sections
- Practical Experience using HJp
- Related Work
- Conclusions
- References
- Verification of Snapshot Isolation in Transactional Memory Java Programs
- Introduction
- StarTM by Example
- Core Language
- Symbolic States
- Symbolic Heaps
- Heap Paths
- From Symbolic Heaps to Heap Paths
- Symbolic Execution
- Past Symbolic Heap
- Symbolic Execution Rules
- Rearrangement Rules
- Fixed Point Computation and Abstraction
- Write-Skew Detection
- Soundness
- Experimental Results
- Related Work
- Concluding Remarks
- References
- Scalable Flow-Sensitive Pointer Analysis for Java with Strong Updates
- Introduction
- Overview
- Access Path-Based Flow-Sensitive Analysis
- Background
- Computing the Set of Access Paths
- Intraprocedural Analysis
- Interprocedural Analysis
- Implementation and Experimental Results
- Related Work
- Conclusion and Future Work
- References
- General-Purpose Analyses
- Application-Only Call Graph Construction
- Introduction
- Background
- Call Graph Construction
- Partial Call Graph Construction
- The Separate Compilation Assumption
- Cgc Overview
- Workflow
- Implementation
- Special Handling of 45java.lang.Object
- Experiments
- Preliminaries and Experimental Setup
- Call Graph Soundness
- Call Graph Precision
- Call Graph Size
- Analysis Performance
- Related Work
- Conclusions and Future Work
- References
- Program Sliding
- Introduction
- Preliminaries
- Control Flow Graph
- Program Scope and State
- Background on Program Dependence
- PDG-Based Sliding
- Source Code Considerations
- Computing the Slice
- Computing the Co-slice
- Correctness Checking and Compensation
- Sliding-Based Refactoring
- Evaluation
- Related Work
- Conclusion
- References
- Static Detection of Loop-Invariant Data Structures
- Introduction
- Overview
- Loop-Invariant Logical Data Structures
- Language, Semantics, and Effect System
- Hoistable Logical Data Structures
- Analysis Algorithm
- Computing Hoistability Measurements
- Evaluation
- Static Analysis and Hoisting
- Case Studies
- Related Work
- Conclusions
- References
- Author Index
