ECOOP 2011--Object-Oriented Programming

Name: ECOOP 2011--Object-Oriented Programming | 25th European Conference. Lancaster, UK, July 25-29, 2011, Proceedings
Brand: Springer
Price: 53.49 EUR
Availability: OnlineOnly

25th European Conference. Lancaster, UK, July 25-29, 2011, Proceedings

Mira Mezini(Herausgeber*in)

Springer (Verlag)

Erschienen am 18. Juli 2011

XIV, 660 Seiten

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-3-642-22655-7 (ISBN)

53,49 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Wasserzeichen-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Inhalt

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

Systemvoraussetzungen

Als PDF speichern Als Link merken