Islands: aliasing protection in object-oriented languages
OOPSLA '91 Conference proceedings on Object-oriented programming systems, languages, and applications
Ownership types for flexible alias protection
Proceedings of the 13th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Featherweight Java: a minimal core calculus for Java and GJ
ACM Transactions on Programming Languages and Systems (TOPLAS)
A parameterized type system for race-free Java programs
OOPSLA '01 Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Encapsulating objects with confined types
OOPSLA '01 Proceedings of the 16th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Java Language Specification, Second Edition: The Java Series
Java Language Specification, Second Edition: The Java Series
Ownership types for safe programming: preventing data races and deadlocks
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Ownership, encapsulation and the disjointness of type and effect
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Alias annotations for program understanding
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Ownership types for object encapsulation
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Simple Ownership Types for Object Containment
ECOOP '01 Proceedings of the 15th European Conference on Object-Oriented Programming
Safejava: a unified type system for safe programming
Safejava: a unified type system for safe programming
Converting java programs to use generic libraries
OOPSLA '04 Proceedings of the 19th annual ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Object ownership and containment
Object ownership and containment
TLDI '05 Proceedings of the 2005 ACM SIGPLAN international workshop on Types in languages design and implementation
Permission-based ownership: encapsulating state in higher-order typed languages
Proceedings of the 2005 ACM SIGPLAN conference on Programming language design and implementation
Protecting representation with effect encapsulation
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
On ownership and accessibility
ECOOP'06 Proceedings of the 20th European conference on Object-Oriented Programming
Linking Programs to Architectures: An Object-Oriented Hierarchical Software Model Based on Boxes
The Common Component Modeling Example
Tunable static inference for generic universe types
Proceedings of the 25th European conference on Object-oriented programming
A calculus for boxes and traits in a java-like setting
COORDINATION'10 Proceedings of the 12th international conference on Coordination Models and Languages
Combining traits with boxes and ownership types in a Java-like setting
Science of Computer Programming
Aliasing in Object-Oriented Programming
Hi-index | 0.00 |
Modular analyses of object-oriented programs need clear encapsulation boundaries between program components. The reference semantics of object-oriented languages complicates encapsulation. Ownership type systems are a way to guarantee encapsulation. However, they introduce a substantial and nontrivial annotation overhead for the programmer. This is in particular true for type systems with an access policy that is more flexible than owners-as-dominators. As we want to use ownership disciplines as basis for modular analyses, we need the flexibility. However, to keep it practical, the annotation overhead should be kept minimal. In this paper, we present such a flexible ownership type system together with an inference technique to reduce the annotation overhead. Runtime components in our approach can be accessed via the interface of the owner as well as via other boundary objects with explicitly declared interface types. The resulting type system is quite complex, however, the programmer only has to annotate the interface types of a component.The ownership type information for the classes implementing the components is automatically inferred by a constraint-based algorithm. We proved the soundness of our approach for a Java-like core language.