ECOOP 2011--Object-Oriented Programming
25th European Conference. Lancaster, UK, July 25-29, 2011, Proceedings
Published on 18. July 2011
XIV, 660 pages
978-3-642-22655-7 (ISBN)
Description
This book constitutes the refereed proceedings of the 25th European Conference on Object-Oriented Programming, ECOOP 2011, held in Lancaster, UK, in July 2011.
The 26 revised full papers, presented together with three keynote lectures were carefully reviewed and selected from a total of 100 submissions. The papers cover topics such as empirical studies, mining, understanding, recommending, modularity, modelling and refactoring, aliasing and ownership; as well as memory optimizations.
More details
Other editions
Additional editions
Mira Mezini
ECOOP 2011--Object-Oriented Programming
25th European Conference. Lancaster, UK, July 25-29, 2011, Proceedings
Book
07/2011
Springer
€53.49
Shipment within 7-9 days
Content
- Title Page
- Preface
- Organization
- Table of Contents
- Keynote 1
- A Co-relational Model of Data for Large Shared Data Banks
- Empirical Studies
- An Empirical Study of Object Protocols in the Wild
- Introduction
- Methodology
- Definitions and Scope
- Experimental Procedure
- Programs Under Analysis
- Risks
- Results
- Protocol Definitions
- Protocol Categories
- Protocol Usage
- Discussion
- Sanity Check
- Widely Used Protocols
- Protocol Categories
- Other Observations
- Future Work
- Related Work
- Conclusion
- References
- The Beauty and the Beast: Separating Design from Algorithm
- Introduction
- Rationale
- Motivation
- Approach
- Overview
- Forest Construction
- Implementation
- Characterization
- Size
- Essence
- Essence by System
- Essence and Design
- Essence and Code Smells
- Essence and Refactorings
- Essence and Design Patterns
- Related Work
- Conceptual Relationship to Existing Metrics
- Empirical Correlation with Existing Metrics
- Discussion
- Usage Scenarios
- Limitations
- Conclusions
- References
- The Eval That Men Do
- Introduction
- The Nature of Eval
- Methodology
- Infrastructure
- Corpus
- Threats to validity
- Usage Metrics
- A Taxonomy of Eval
- Operation Mix
- Scope
- Patterns
- Provenance
- Consistency
- Other Faces of Eval
- Case Studies
- Related Work
- Conclusion
- References
- Patterns
- Performance Impact of Eval
- Local vs. Global Scope
- Mining, Understanding, Recommending
- Using Structure-Based Recommendations to Facilitate Discoverability in APIs
- Introduction
- Motivation
- API Explorer
- API Graph and Recommendation Algorithms
- API Exploration Graph
- Object Construction Algorithm
- Method Recommendation Algorithm
- Relationship Exploration Algorithm
- Code Generation Algorithm
- Design Rationale
- Evaluation
- Case Study Design
- Results
- Summary
- Threats to validity
- Related work
- Conclusion
- References
- Mining Evolution of Object Usage
- Introduction
- Object Usage Evolution
- Temporal Properties
- Change Properties
- Mining Patterns
- Detecting Evolution Patterns
- Finding Missing Changes
- Evaluation
- Detecting Errors
- Preventing Errors
- Threats to Validity
- Related Work
- Learning Evolution Rules
- Learning from Project History
- Conclusion and Consequences
- References
- Improving the Tokenisation of Identifier Names
- Introduction
- The Identifier Name Tokenisation Problem
- The Composition of Identifier Names
- Tokenising Identifier Names
- Related Work
- Approach
- Oracles
- Tokenising Conventionally Constructed Identifier Names
- Tokenising Identifier Names Containing Digits
- Tokenising Single Case Identifier Names
- Experiments and Results
- INTT
- Comparison with Samurai
- Single Case Identifier Names
- Threats to Validity
- Discussion
- Identifier Names Containing Digits
- Limitations
- Conclusions
- References
- Modularity
- Revisiting Information Hiding: Reflections on Classical and Nonclassical Modularity
- Introduction
- Modularity and Classical Logic
- Information Hiding and Abstraction
- Reductionism and Compositionality
- Idealization
- Monotonicity
- Summary
- Programmers Use Nonclassical Reasoning
- Programmers Use Inductive Reasoning
- Programmers Use Default Reasoning and Occam's Razor
- Programmers Use Negation as Failure and Closed-World Reasoning
- Discussion
- Limits of Information Hiding
- Operational Behavior and Interface Detail
- Large Systems
- Separation of Concerns and the Dominant Decomposition
- Software Evolution
- Information Hiding and Classical Logic
- Programs Are Not Models
- Towards Nonclassical Modularity
- Conclusions
- References
- Worlds: Controlling the Scope of Side Effects
- Introduction
- Approach
- Worlds/JS
- Safety Properties
- Worlds by Example
- Better Support for Exceptions
- Undo for Applications
- Extension Methods in JavaScript
- Property Lookup Semantics
- Property Lookup in JavaScript
- Property Lookup in Worlds/JS
- Implementation
- Data Structures
- The Slot Update Operation: (xi v)w
- The Slot Lookup Operation: (xi)w
- Reads and Writes in the Top-Level World
- The Commit Operation
- Pulling It all Together
- Case Study #1: A Bitmap Editor
- The Implementation of Tree Undo
- Bitmap Representation
- Benchmarking the Bitmap Editor
- Case Study #2: OMeta + Worlds
- Related Work
- Conclusions and Future Work
- References
- Can We Avoid High Coupling?
- Introduction
- Scale-Free Structure and Its Application to Software
- Power-Lawdistributions
- Empirical Findings
- Process Models Leading to Scale-Free Structure
- Model
- Connectivity and Evolvability
- Scale-Free Structure in Overall Connectivity
- Scale-Free Structure in Between-Module Connectivity
- Empirical Study
- Graph-Based Source Code Representation
- Identification of Within-Module and Between-Module Links
- Analysis
- Overall Connectivity
- Between-Module Connectivity
- Discussion
- Threats to Validity
- Near-Constant for Between-Module Connectivity
- Varieties of Coupling
- Conclusion
- References
- Keynote 2
- Expressiveness, Simplicity, and Users
- Modelling and Refactoring
- CDDiff: Semantic Differencing for Class Diagrams
- Introduction
- Examples
- Example I
- Example II
- Example III
- Preliminaries
- Class Diagrams Language
- A Brief Overview of Alloy
- CDDiff
- Definitions
- Computing cddiffk: Overview
- Computing cddiffk: The Generated Alloy Module
- Implementation and Evaluation
- Browsing Diff Witnesses
- High-Level Evolution Analysis
- Performance
- Extensions: Filtering and Abstraction
- Filtering Diff Witnesses
- Abstraction
- Discussion and Future Directions
- Bounded Analysis and the Small Scope Hypothesis
- Integration With Operation-Based and Syntactic Differencing
- Related Work
- CD Formal Semantics and Analysis
- Model and Program Comparisons
- Conclusion
- References
- A Refactoring Constraint Language and Its Application to Eiffel
- Introduction
- Motivation and Related Work
- A Generalized Framework of Constraint-Based Refactoring
- Program Elements, Kinds, and Properties
- Domains
- Constraints, Constraint Rules, and Constraint-Based Refactoring
- Program Queries and Writing Back Solutions
- Specifying a Refactoring
- Challenges of Constraint-Based Refactoring
- Indirection
- Reducing the Solution Space: Generating the Necessary Constraints Only
- Determining the Best Solution: Soft Constraints
- Defaults and Introductions
- Miscellaneous
- The Refactoring Constraint Language REFACOLA
- The REFACOLA Language and Framework
- Implementation of the Compiler
- Application
- The RENAME Refactorings
- The CHANGE ACCESSIBILITY Refactoring
- The CHANGE DECLARED TYPE Refactoring
- Combining Several Refactorings into One
- Experimental Results
- Conclusion
- References
- Modal Object Diagrams
- Introduction
- Examples
- Example I
- Example II
- Modal Object Diagrams
- Class Diagrams and Object Diagrams
- Defining Modal Object Diagrams
- Verifying a CD against an MOD Specification
- Problem Definition
- A Brief Overview of Alloy
- Solution by Transformation to Alloy
- Implementation and Evaluation
- Example Results
- Performance Results
- Extensions
- Partial vs. Complete Positive Examples
- Parametrized Object Diagrams
- Discussion and Future Work
- Complexity and Performance
- The Bounded Scope Limitation
- MOD and OCL
- Using MODs in the Design Process
- Synthesis and Unsatisfiable Cores
- Related Work
- Conclusion
- References
- Aliasing and Ownership
- Types, Regions, and Effects for Safe Programming with Object-Oriented Parallel Frameworks
- Introduction
- Background
- Safe, Reusable Parallel Frameworks
- A List Node Container
- Getting More Flexibility
- Writing the Framework Implementation
- Formal Elements
- Syntax
- Static Semantics
- Dynamic Semantics
- Valid Execution State
- Soundness Results
- Evaluation
- DPJ Frameworks
- Client Code
- Discussion of Evaluation Results
- Related Work
- Conclusion
- References
- Tunable Static Inference for Generic Universe Types
- Introduction
- Background on Generic Universe Types
- Inference Approach and Example
- Inference Approach
- Iterative Usage
- Tunable Static Inference
- Programming Language
- Building the Constraints
- Heuristic Choice of a Solution
- Encoding for a SAT Solver
- Implementation and Experience
- Implementation
- Experience
- Future Work
- Related Work
- Conclusion
- References
- Verifying Multi-object Invariants with Relationships
- Introduction
- Running Example
- First-Class Relationships
- Language Principles
- Assertion Language
- The Metapost
- Stratification
- Admissibility Criteria
- Verification Technique
- Background
- Proof Obligations
- Discussion and Related Work
- Conclusions
- References
- Pre- and Postconditions for Composite Specification
- Memory Optimizations
- Patterns of Memory Inefficiency
- Introduction
- The Memory Patterns
- Patterns P1-P3: Empty, Fixed, Small Collections
- Pattern P4: Sparsely Populated Collections
- Pattern P5: Small Primitive Arrays
- Pattern P6: Boxed Scalar Collections
- Pattern P7: Wrapped Collections
- Pattern P8: Highly Delegated Structures
- Pattern P9: Nested Collections
- Pattern P10: Sparse References
- Pattern P11: Primitive Array Wrappers
- The ContainerOrContained Abstraction
- Heap Snapshots and the Object Reference Graph
- Limitations of the Dominator Relation
- Roles, and the ContainerOrContained Model
- How Roles Imply Per-Object and Total Overhead
- Regions, and the ContainerOrContained DAG
- Detecting Pattern Occurrences, and Aggregating Them by Context
- Client Analyses
- Experiences with Our Tool
- Validation and Characterization
- How Much of the Overhead Do the Patterns Explain?
- How Many Contexts Does a User Need to Look at?
- How Many Different Types of Problems Exist in a Single Heap?
- How often Do the Pattern Categories Appear across Applications?
- Additional Sources of Inefficiency
- Related Work
- Conclusions
- References
- Reuse, Recycle to De-bloat Software
- Introduction
- Preliminaries
- Finding Potential Sources of Bloat
- The Problem with Loop Carried Data Dependence
- The Basic Algorithm
- Multiple Control Dependence Paths
- Object Reuse, Recycle Transformations
- Basic Reuse-Recycle Algorithm
- Reusing Collections
- Reusing Strings
- Implementation Details
- Dynamic Analysis Guided Filtering of Candidate Reuse Sites
- Discussion
- Empirical Evaluation
- Reuse Site Detection Statistics (static analysis)
- Reuse Site Object Churn Statistics (dynamic analysis)
- Performance Impact Statistics
- Related Work
- Conclusion and Future Work
- References
- Keynote 3
- A Featherweight Approach to FOOL
- Types
- Related Types
- Introduction
- Unintended Dead Code
- Related Work
- Relatedness
- Related vs. Unrelated
- Relatedness
- Value Subtype
- Relatedness and Value Subtyping
- Type Annotations
- The Related Type
- Examples of Use
- Related Types and Variance
- Bounds on Related Types
- Type Rules
- Experiments
- Work-in-Progress Code Tests
- Production Code Tests
- Conclusion
- References
- Error Examples
- Conceptual Identity: Lookup
- Conceptual Identity: Build Hierarchy
- Off-by-One: ModelChannelMixer vs. SoftChannelMixerContainer
- Off-by-One: Win32ShellFolder2
- Conceptual Mismatch: ProjectDescription
- Conceptual Mismatch: Argument Types
- Gradual Typestate
- Introduction
- Typestate-Oriented Programming
- Static Featherweight Typestate
- Syntax
- Managing Permissions
- Static Semantics
- Holding Permissions
- Gradual Featherweight Typestate
- Internal Language
- Syntax
- Static Semantics
- Dynamic Semantics
- Type safety
- Source to Target Translation
- Discussion
- References
- Maintaining Database Integrity with Refinement Types
- Introduction
- Background: Database Integrity Constraints
- Background: Multi-tier Functional Programming
- Databases and Refinement Types
- Transactions and the Refined State Monad
- An Architecture for Verified Database Transactions
- Contributions of the Paper
- A Tool to Model SQL with Refinement Types
- SQL Schemas: Tables and Stored Procedures
- Generating Types and Database Interfaces from Schemas
- Reference Implementation of Database Interface
- Extension with Application Constraints
- Completing the Marriages Example
- Database Schema
- Access Function API
- User-Written Transactions
- Example: A Simple E-Commerce Application
- Example: A Heap-Ordered Tree
- Software Architecture and Evaluation
- Related Work
- Conclusion
- References
- Runtime and Memory Optimizations
- Frequency Estimation of Virtual Call Targets for Object-Oriented Programs
- Introduction
- Motivating Example
- Potential Applications
- Approach
- Preprocessing
- Static Feature Set
- Estimation Model
- Evaluation
- Experimental Design
- Rank Correlation Analysis
- Top Target Prediction
- Weight Matching Analysis
- Predictive Power Analysis
- Discussion
- Threats to Validity
- Related Work
- Conclusions and Future Work
- Reference s
- Counting Messages as a Proxy for Average Execution Time in Pharo
- Introduction
- Profiling Based on Execution Sampling
- Counting Messages as a Proxy for Execution Time
- Execution Time and Number of Message Sends
- Method Invocation
- Effect of the Execution Context
- Tracking Optimizations
- Cost of Counting Messages
- Counting Messages to Identify Execution Bottlenecks
- A Method as an Execution Bottleneck
- Method Invocations Per Method
- Method Execution Time and Number of Message Sends
- Stability of Message Counting
- Cost of the Instrumentation
- Contrasting Execution Sampling with Message Counting
- Implementation
- Discussion
- Related Work
- Conclusion
- References
- Linear Regression Material
- Summarized Trace Indexing and Querying for Scalable Back-in-Time Debugging
- Introduction
- Summarized Trace Indexing and Querying
- Process Overview
- System Architecture
- Trace Capture and Partial Deterministic Replay
- Capture
- Initial Replay
- Snapshots
- Indexing of Control Flow
- Range Min-Max Tree
- Indexing and Querying
- Indexing of Memory Accesses
- Index Structure and Querying
- Pipelined Index Construction
- Local Variables
- Benchmarks
- Global Results
- Cost of Individual Features
- Related Work
- Conclusion
- References
- Exceptions
- Interprocedural Exception Analysis for C++
- Introduction
- Preliminaries
- Signed-TypeSet Domain
- Intraprocedural Exception Control Flow Graph
- Interprocedural Exception Analysis
- Generating an Exception-Free Program
- Implementation and Experiments
- Related Work
- Conclusions and Future Work
- References
- Detecting and Escaping Infinite Loops with Jolt
- Introduction
- Automatic Detecting and Escaping Infinite Loops
- Evaluation
- Contributions
- The Jolt System
- Example
- Infinite Loop
- Compilation
- Detection
- User Interaction
- Escaping the Infinite Loop
- Implementation
- Static Instrumentor
- Dynamic Instrumentor
- Empirical Evaluation
- Benchmarks
- Methodology
- Results
- Selected Case Studies
- Grep
- Indent
- Performance
- Instrumentation Overhead
- Infinite Loop Detection
- Limitations
- Related Work
- Conclusion
- Atomic Boxes: Coordinated Exception Handling with Transactional Memory
- Introduction
- Background and Related Work
- A Running Example
- Syntax and Semantics
- Normal Mode Constructs
- Failure Mode Constructs
- Redirecting Control Flow after Recovery
- Nesting of Atomic Boxes
- Resolution of Concurrently Raised Exceptions
- Atomic Boxes Implementation
- Language Support for Atomic Boxes
- Transactional Memory Wrappers
- Bytecode Instrumentation
- Evaluation
- Producer-Consumer Example
- Sorting Examples
- Conclusion and Future Work
- References
- Author Index
