A Type-Safe Model of Adaptive Object Groups

Services are autonomous, self-describing, technology-neutral software units that can be described, published, discovered, and composed into software applications at runtime. Designing software services and composing services in order to form applications or composite services requires abstractions beyond those found in typical object-oriented programming languages. This paper explores service-oriented abstractions such as service adaptation, discovery, and querying in an object-oriented setting. We develop a formal model of adaptive object-oriented groups which offer services to their environment. These groups fit directly into the object-oriented paradigm in the sense that they can be dynamically created, they have an identity, and they can receive method calls. In contrast to objects, groups are not used for structuring code. A group exports its services through interfaces and relies on objects to implement these services. Objects may join or leave different groups. Groups may dynamically export new interfaces, they support service discovery, and they can be queried at runtime for the interfaces they support. We define an operational semantics and a static type system for this model of adaptive object groups, and show that well-typed programs do not cause method-not-understood errors at runtime.Comment: In Proceedings FOCLASA 2012, arXiv:1208.432

Composition and refinement for partial object specifications

Due to the complexity involved in the specification and development of large, distributed, and object-oriented systems, it is often advocated that individual components should be developed in an aspect-wise manner, where separate descriptions depict various roles, viewpoints, or interfaces of the objects considered. The introduction of such partial specifications requires extra care when reasoning about systems as several specifications of the same object may coexist and lead to overlapping information. In this paper, we consider a compositional approach to system development by means of partial specifications of objects. The approach supports stepwise refinement, which enables global reasoning by local refinement steps in an aspect-oriented specification style. For this purpose, a refinement relation is proposed which is suitable for multiple inheritance of behavior and subclassing in object-oriented languages

A Proof Environment for Partial Specifications in OUN

Aspect-oriented specifications and formal reasoning are often advocated for the design of complex, distributed systems. Commonly used design notations seem to lack the reasoning control of formal languages. OUN is an object-oriented language with facilities for aspect-oriented specifications through multiple viewpoints and for reasoning control. However, to be of practical use the language needs tool support. In this paper, we propose a formalization of aspects of the observable behavior of objects, using the PVS proof system. The formalism is extended with constructs to provide reasoning support for OUN specifications.

Observable behavior of dynamic systems: component reasoning for concurrent objects

Current object-oriented approaches to distributed programs may be criticized in several respects. First, method calls are generally synchronous, which leads to muc

A compositional proof system for dynamic object systems

Current object-oriented approaches to distributed programs may be criticized in several respects. First, method calls are generally synchronous, which leads to much waiting in distributed and unstable networks. Second, the common model of thread concurrency makes reasoning about program behavior very challenging. Object-oriented models based on concurrent objects communicating by asynchronous method calls, have been proposed to combine object orientation and distribution in a more satisfactory way. In this report, a high-level language and proof system are developed for such a model, emphasizing simplicity and modularity. In particular, the proof system is used to derive external specifications of observable behavior for objects, encapsulating their state. A simple and compositional proof system is paramount to allow verification of real programs. The proposed proof rules are derived from the Hoare rules of a standard sequential language by a semantic encoding preserving soundness and relative completeness. Thus, the report demonstrates that these models not only address the first criticism above, but also the second

A dynamic class construct for asynchronous concurrent objects

Abstract Modern applications distributed across networks such as the Internet may need to evolve without compromising application availability. Object systems are well suited for runtime upgrade, as encapsulation clearly separates internal structure and external services. This paper considers a mechanism for dynamic class upgrade, allowing class hierarchies to be upgraded in such a way that the existing objects of the upgraded class and of its subclasses gradually evolve at runtime. The mechanism is integrated in Creol, a high-level language which targets distributed applications by means of concurrent objects communicating by asynchronous method calls. The dynamic class construct is given a formal semantics in rewriting logic, extending the semantics of the Creol language.