The proceedings contain 6 papers. The topics discussed include: retrieving relationships from declarative files;implementing relationships using affinity;implementing relationships among classes of analysis pattern la...
The proceedings contain 6 papers. The topics discussed include: retrieving relationships from declarative files;implementing relationships using affinity;implementing relationships among classes of analysis pattern languages using aspects;implementing UML associations in Java;nested and specialized associations;and roles in building web applications using Java.
The proceedings contain 26 papers. The topics discussed include: coinductive type systems for object-oriented languages;checking framework interactions with relationships;COPE - automating coupled evolution of metamod...
ISBN:
(纸本)3642030122
The proceedings contain 26 papers. The topics discussed include: coinductive type systems for object-oriented languages;checking framework interactions with relationships;COPE - automating coupled evolution of metamodels and models;scaling CFL-reachability-based points-to analysis using context-sensitive must-not-alias analysis;NePaLTM: design and implementation of nested parallelism for transactional memory systems;implicit dynamic frames: combining dynamic frames and separation logic;fine-grained access control with object-sensitive roles;practical API protocol checking with access permissions;adding state and visibility control to traits using lexical nesting;featherweight jigsaw: a minimal core calculus for modular composition of classes;and modular visitor components: a practical solution to the expression families problem.
The proceedings contain 4 papers. The topics discussed include: interfaces of active objects with internal concurrency;Beernet: RMI-free peer-to-peer networks;language support for distributed proxies;and language desi...
ISBN:
(纸本)9781605585451
The proceedings contain 4 papers. The topics discussed include: interfaces of active objects with internal concurrency;Beernet: RMI-free peer-to-peer networks;language support for distributed proxies;and language design for distributed objects.
object-Orientation is now over forty years old. In that time, object-orientedprogramming has moved from a Scandinavian cult to a world-wide standard. In this talk I'll revisit the essential principles myths - of ...
详细信息
ISBN:
(纸本)9783642030123
object-Orientation is now over forty years old. In that time, object-orientedprogramming has moved from a Scandinavian cult to a world-wide standard. In this talk I'll revisit the essential principles myths - of of object-orientation, and discuss their role in the evolution of languages from SIMULA to Smalltalk to C++ to Java and beyond. Only by keeping the object-oriented faith can we ensure full-spectrum object-oriented dominance for the next forty years in the project for a new object-oriented century!
OO languages typically provide one form of object equality, known as reference equality, where two objects are equal only if they are the same object;two objects which are structurally identical are not considered equ...
详细信息
OO languages typically provide one form of object equality, known as reference equality, where two objects are equal only if they are the same object;two objects which are structurally identical are not considered equal. Thus, programmers who require a more refined notion of equality must define their own operator. Programmerimplemented equality operators tend to rely on informal notions of partial and temporal object immutability which are prone to error. This is a particular problem for objects used in collections which depend on equality. This paper discusses Affinity: an untyped, object-oriented language with a powerful equality operator based on EGAL [2] and support for object-keying and immutability. Affinity is designed to provide coherent and elegant support for object equality, reducing programmer burden and error potential. Copyright 2009 ACM.
Patterns within an analysis pattern language are related to each other in several ways: the application of a pattern can result in the application of another, a pattern can be applied only if another pattern was appli...
详细信息
Patterns within an analysis pattern language are related to each other in several ways: the application of a pattern can result in the application of another, a pattern can be applied only if another pattern was applied (or was not applied), etc. Also, several variants of a pattern may co-exist, and the application of a particular variant can lead to the inclusion or removal of associations between classes that form the pattern. In this paper, we show how we have used aspectorientedprogramming to implement relationships between classes of an analysis pattern or between classes shared by more than one pattern. This allows the incremental development of a framework to support the pattern language, and also eases the instantiation of patterns and pattern variants. Copyright 2009 ACM.
The dynamic frames approach has proven to be a powerful formalism for specifying and verifying object-oriented programs. However, it requires writing and checking many frame annotations. In this paper, we propose a va...
详细信息
ISBN:
(纸本)9783642030123
The dynamic frames approach has proven to be a powerful formalism for specifying and verifying object-oriented programs. However, it requires writing and checking many frame annotations. In this paper, we propose a variant of the dynamic frames approach that eliminates the need to explicitly write and check frame annotations. Reminiscent of separation logic's frame rule, programmers write access assertions inside pre- and postconditions instead of writing frame annotations. From the precondition, one can then infer an upper bound on the set of locations writable or readable by the corresponding method. We implemented our approach in a tool, and used it to automatically verify several challenging programs, including subject-observer;iterator and linked list.
We propose a novel approach based on coinductive logic to specify type systems of programming languages. The approach consists in encoding programs in Horn formulas which are interpreted w.r.t. their coinductive Herbr...
详细信息
ISBN:
(纸本)9783642030123
We propose a novel approach based on coinductive logic to specify type systems of programming languages. The approach consists in encoding programs in Horn formulas which are interpreted w.r.t. their coinductive Herbrand model. We illustrate the approach by first specifying a standard type system for a small object-oriented language similar to Featherweight Java. Then we define an idealized type system for a variant of the language where type annotations can be omitted. The type system involves infinite terms and proof trees not representable in a finite way, thus providing a theoretical limit to type inference of object-oriented programs, since only sound approximations of the system can be implemented. Approximation is naturally captured by the notions of subtyping and subsumption;indeed, rather than increasing the expressive power of the system, as it usually happens, here subtyping is needed for approximating infinite non regular types and proof trees with regular ones.
We present a type system for checking object immutability, read-only references, and class immutability in an open or closed world. To allow object initialization outside object constructors (which is often needed in ...
详细信息
ISBN:
(纸本)9783642030123
We present a type system for checking object immutability, read-only references, and class immutability in an open or closed world. To allow object initialization outside object constructors (which is often needed in practice), immutable objects are initialized in lexically scoped regions. The system is simple and direct;its only type qualifiers specify immutability properties. No auxiliary annotations, e.g., ownership types, are needed, yet good support for deep immutability is provided. To express object confinement, as required for class immutability in an open world, we use qualifier polymorphism. The system has two versions: one with explicit specification commands that delimit the object initialization phase, and one where such commands are implicit and inferred. In the latter version, all annotations are compatible with Java's extended annotation syntax, as proposed in JSR 308.
暂无评论