Alias annotations for program understanding

@inproceedings{Aldrich2002AliasAF,
  title={Alias annotations for program understanding},
  author={Jonathan Aldrich and Valentin Kostadinov and Craig 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… 

Figures from this paper

A Summary of AliasJava and some related works

TLDR
AliasJava combines uniqueness and ownership annotations to express idioms that neither system is capable of expressing in isolation.

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.

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.

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.

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.

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.

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.

Modular Checking of Confinement for Object-Oriented Components using Abstract Interpretation

TLDR
A very lightweight approach to add encapsulation support to a Java-like language by annotating class declarations and new statements to express which classes instantiate new components and which objects are confined to their surrounding component.

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.

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.
...

References

SHOWING 1-10 OF 51 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.

Lackwit: A Program Understanding Tool Based on Type Inference

  • R. O'CallahanD. 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.

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.

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.

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.

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.

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.

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.

Adoption and focus: practical linear types for imperative programming

TLDR
A new type system that reduces restrictions on aliasing with the adoption and focus constructs is proposed, which safely allows a programmer to alias objects on which she is checking protocols, and focus allows the reverse.
...