Learn More
The Java language lacks the important notions of <i>ownership</i> (an object owns its representation to prevent unwanted aliasing) and <i>immutability</i> (the division into mutable, immutable, and readonly data and references). Programmers are prone to design errors, such as representation exposure or violation of immutability contracts. This paper(More)
Traditional ownership types organise the heap into a tree. Ownership types can support memory management, real-time systems, concurrency, parallelism, and general purpose reasoning about programs. Trees, however, are too restrictive to describe many real programs, limiting the usability of conventional ownership systems. Multiple ownership organises the(More)
Ownership systems express hierarchical data structures well but can have difficulty expressing relationships between peers. Relationships systems, on the other hand, do not address ownership issues. This paper considers the recent work on relationship systems in the context of ownership, and presents ideas for adding ownership to relationship systems.
The JAVA language has no support for the important notions of ownership (an object owns its representation to prevent unwanted aliasing or modifications) and immutability (the division into mutable, immutable, and readonly data and references). Programmers are prone to design errors such as representation exposure or violation of immutability contracts.(More)
Object-oriented programmers often need to clone objects. Mainstream languages, such as C# and Java, typically default to shallow cloning, which copies just one object and aliases references from that object. Other languages, such as Eiffel, provide deep cloning. A deep clone is a copy of the entire object graph reachable from the cloned object, which could(More)
  • 1