Alias annotations for program understanding

@inproceedings{Aldrich2002AliasAF,
  title={Alias annotations for program understanding},
  author={J. Aldrich and Valentin Kostadinov and C. Chambers},
  booktitle={OOPSLA '02},
  year={2002}
}
One of the primary challenges in building and evolving large object-oriented systems is understanding aliasing between objects. Unexpected aliasing can lead to broken invariants, mistaken assumptions, security holes, and surprising side effects, all of which may lead to software defects and complicate software evolution.This paper presents AliasJava, a capability-based alias annotation system for Java that makes alias patterns explicit in the source code, enabling developers to reason more… Expand
A Summary of AliasJava and some related works
AliasJava [AKC02] is a type annotation system for placing structural and temporal bounds on data sharing in Java programs. In the annotation system, unique describes an unshared reference, ownedExpand
Inferring aliasing and encapsulation properties for java
TLDR
This work presents Uno, a novel static analysis for automatically inferring ownership, uniqueness, and other aliasing and encapsulation properties in Java, and finds that some aliasing properties are common, while others, in particular field and argument ownership, are relatively uncommon. Expand
OwnKit: Inferring Modularly Checkable Ownership Annotations for Java
TLDR
This paper presents Own Kit - a system for automatically inferring ownership annotations which are modularly checkable and evaluates the approach on a number of real-world benchmarks and compares against an existing system. Expand
JavaD: Bringing Ownership Domains to
TLDR
JavaD, a re-implementation of the AliasJava language and analysis as a set of Java 1.5 annotations, is presented and evaluated, using the Eclipse Java Development Tooling (JDT) infrastructure and the Crystal Data Flow Analysis framework. Expand
Runtime Universe Type Inference
TLDR
This paper describes how the execution of programs can be analyzed and infer ownership modifiers from the execution, which help to understand the organization of a system and can also be re-inserted into the original source code. Expand
Checking ownership and confinement
TLDR
Analysis of heap snapshots from a corpus of Java programs indicates that object‐oriented programs do in fact exhibit symptoms of encapsulation in practice, and that proposed models of uniqueness, ownership, and confinement can usefully describe the aliasing structures of object-oriented programs. Expand
Instrumenting annotated programs
TLDR
It is shown how the annotations can expose enough information about themselves to prevent the instrumentation from accidentally corrupting the annotations, and an annotation taxonomy is proposed and demonstrated. Expand
Modular Checking of Confinement for Object-Oriented Components using Abstract Interpretation
The ability to express confinement properties of objects is crucial in the context of component-oriented software development. Recently, several techniques based on type systems have been developedExpand
Annotations for (more) Precise Points-to Analysis
TLDR
This work extends an existing points-to analysis for Java and proposes an annotation language that permits a modular analysis without losing too much precision and allows concise specification of points- to and read/write effects. Expand
JavaD: Bringing Ownership Domains to Mainstream Java
TLDR
JavaD, a re-implementation of the AliasJava language and analysis as a set of Java 1.5 annotations, using the Eclipse Java Development Tooling (JDT) infrastructure and the Crystal Data Flow Analysis framework is presented. Expand
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 64 REFERENCES
Generalized aliasing as a basis for program analysis tools
TLDR
The design of a system, Ajax, that addresses the problem of aliasing by using semantics-based program analysis as the basis for a number of different tools to aid Java programmers, and is the first system to address this particular task. Expand
Lackwit: A Program Understanding Tool Based on Type Inference
  • R. O'Callahan, D. Jackson
  • Computer Science
  • Proceedings of the (19th) International Conference on Software Engineering
  • 1997
TLDR
A prototype tool is used to answer a user’s questions about a 17,000 line program written in C, and representation sharing with type inference is computed, using types to encode representations. Expand
Flexible Alias Protection
TLDR
Using flexible alias protection, programs can incorporate mutable objects, immutable values, and updatable collections of shared objects, in a natural object oriented programming style, while avoiding the problems caused by aliasing. Expand
Promises: limited specifications for analysis and manipulation
TLDR
An annotation mechanism called promises is described for expressing properties that can enable many kinds of structural change in systems, and is suggested as a means to allocate flexibility among the components of a system. Expand
Encapsulating objects with confined types
TLDR
Kacheck/J is able to infer confinement—the property that all instances of a given type are encapsulated in their defining package, which can be used to identify accidental leaks of sensitive objects, as well as for compiler optimizations. Expand
Alias annotations for program understanding
One of the primary challenges in building and evolving large object-oriented systems is understanding aliasing between objects. Unexpected aliasing can lead to broken invariants, mistaken assumptio...
Ownership types for flexible alias protection
TLDR
Ownership types form a static type system that indicates object ownership, which provides a flexible mechanism to limit the visibility of object references and restrict access paths to objects, thus controlling a system's dynamic topology. Expand
Object ownership and containment
TLDR
This work proves the soundness of the ownership types system and demonstrates that well-typed programs satisfy the containment invariant, and provides a firm grounding to enable ownership types to be safely added to an object-oriented programming language with inheritance, subtyping, and nested classes. Expand
Capabilities for Sharing: A Generalisation of Uniqueness and Read-Only
TLDR
This paper shows how annotations on pointer variables such as “read-only,” “unique,’ and “borrowed” can be subsumed into a general capability system for pointers, which has a welldefined semantics and supports research in new less-restrictive type systems that permit a wider range of idioms to be statically checked. Expand
Confined types
TLDR
A verifier is implemented which performs a modular analysis of Java programs and provides a static guarantee that confinement is respected, and two mechanisms: confined types to impose static scoping on dynamic object references and anonymous methods which are methods that do not reveal the identity of the current instance. Expand
...
1
2
3
4
5
...