ECOOP 2012 -- Object-Oriented Programming

Name: ECOOP 2012 -- Object-Oriented Programming | 26th European Conference, Beijing, China, June 11-16, 2012, Proceedings
Brand: Springer
Price: 53.49 EUR
Availability: OnlineOnly

26th European Conference, Beijing, China, June 11-16, 2012, Proceedings

James Noble(Herausgeber*in)

Springer (Verlag)

Erschienen am 28. Juni 2012

XIV, 766 Seiten

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-3-642-31057-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
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

Systemvoraussetzungen

Als PDF speichern Als Link merken