Virtual classes are class-valued attributes of objects. Like virtual methods, virtual classes are defined in an object’s class and may be redefined within subclasses. They resemble inner classes, which are also defined within a class, but virtual classes are accessed through object instances, not as static components of a class. When used as types, virtual classes depend upon object identity – each object instance introduces a new family of virtual class types. Virtual classes support large-scale program composition techniques, including higher-order hierarchies and family polymorphism. The original definition of virtual classes in BETA left open the question of static type safety, since some type errors were not caught until runtime. Later the languages Caesar and gbeta have used a more strict static analysis in order to ensure static type safety. However, the existence of a sound, statically typed model for virtual classes has been a long-standing open question. This paper presents a virtual class calculus, vc, that captures the essence of virtual classes in these full-fledged programming languages. The key contributions of the paper are a formalization of the dynamic and static semantics of vc and a proof of the soundness of vc. Categories and Subject Descriptors D.3.3 [Language Constructs and Features]: Classes and objects, inheritance, polymorphism; F.3.3 [Studies of Program Constructs]: Object-oriented constructs,

Object-oriented distributed computing is becoming increasingly important for critical infrastructure in society. In standard object-oriented models, objects synchronize on method calls. These models may be criticized in the distributed setting for their tight coupling of communication and synchronization; network delays and instabilities may locally result in much waiting and even deadlock. The Creol model targets distributed objects by a looser coupling of method calls and synchronization. Asynchronous method calls and high-level local control structures allow local computation to adapt to network instability. Object variables are typed by interfaces, so communication with remote objects is independent from their implementation. The inheritance and subtyping relations are distinct in Creol. Interfaces form a subtype hierarchy, whereas multiple inheritance is used for code reuse at the class level. This paper presents the Creol syntax, operational semantics, and type system. It is shown that runtime type errors do not occur for well-typed programs.

In this paper we start from the consideration that high level interaction between entities like web services has very different properties with respect to the interaction between objects at the lower level of programming languages in the object oriented paradigm. In particular, web services, for security, usability and user adaptability reasons, offer different operations to different users by means of access control and keep track of the state of the interaction with each user by means of sessions. The current vision in object orientation, instead, considers attributes and operations of objects as being objective and independent from the interaction with another object, which is sessionless. To introduce these features in the interaction between objects directly in object oriented programming languages, we take inspiration from how access control is regulated by means of roles. Roles allow objects to offer different operations depending on the type of the role, of the type and identity of the player of the role, and to define session-aware interaction. We start from a definition of roles given in ontologies and knowledge representation and we discuss how this definition of roles can be introduced in Java, building our language powerJava.

Abstract. In this paper we present a new vision of objects in knowledge representation where the objects ’ attributes and operations depend on who is interacting with them. This vision is based on a new definition of the notion of role, which is inspired by the concept of affordance as developed in cognitive science. The current vision of objects considers attributes and operations as being objective and independent from the interaction. In contrast, in our model interaction with an object always passes through a role played by another object manipulating it. The advantage is that roles allow to define operations whose behavior changes depending on the role and the requirements it imposes, and to define session aware interaction, where the role maintains the state of the interaction with an object. Finally, we provide a description of the model in UML and we discuss how roles as affordances have been introduced in Java. 1

Summary. Agent technology is widely perceived to be a viable solution for largescale industrial and commercial applications in dynamic environments such as the Internet. However, the lack of rigour and language support in the analysis, specification, design and implementation of multi-agent systems has hampered the wide adoption of agent technology. This paper proposes a model-driven approach to the development of multi-agent systems. It combines graphic modelling with formal specification through automated tools. The paper reports an agent-oriented modelling language CAMLE and the automated tools in its modelling environment. Two aspects of particular importance in the model-driven development methodology are addressed in this paper. The first is the definition and implementation of consistency constraints on graphic models. The second is the automated transformation of graphic models into formal specifications. 1

In previous work on the language Fickle and its extension Fickle_II Dezani and us introduced language features for object re-classification for imperative, typed, class-based, object-oriented languages. In this paper we present...

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

this paper we consider re-classification in the presence of multi-threading. To this aim we define a multi-threaded extension of the language MT . We define an operational semantics and a type and e#ect system for the language. Each method signature carries the information on the possible e#ects of the method execution. The type and e#ect system statically checks this information. The operational semantics uses this information in order to delay the execution of some threads when this could cause access to non-existing members of objects. We show that in the execution of a well-typed expression such delays do not produce deadlock

Ferruccio Damiani + Universit a di Torino Corso Svizzera 185 damiani@di.unito.it Mariangiola Dezani-Ciancaglini # Universit a di Torino Corso Svizzera 185 dezani@di.unito.it Paola Giannini Universit a del Piemonte Orientale Corso Borsalino 54 15100 Alessandria, Italy giannini@mfn.unipmn.it ABSTRACT In this paper we consider re-classification in the presence of multi-threading. To this aim we define a multi-threaded extension of the language MT . We define an operational semantics and a type and e#ect system for the language. Each method signature carries the information on the possible e#ects of the method execution. The type and e#ect system statically checks this information. The operational semantics uses this information in order to delay the execution of some threads when this could cause messageNotUnderstood errors. We prove that in the execution of a well-typed expression such delays do not produce deadlock.

Key words. Distributed systems, object-oriented programming, asynchronous method calls, type and effect systems, type soundness In the distributed setting, the object-oriented programming model may be criticized for its tight coupling of communication and synchronization, found in, e.g., remote procedure calls. Creol is a novel object-oriented language which targets distributed systems by combining asynchronous method calls with so-called processor release points inside concurrent objects [3]. A type system for Creol and a corresponding type soundness result is presented in [4]. Asynchronous method calls complicate the type analysis by decoupling input and output information for method calls, leading to a complex type and effect system [6] to track information during type analysis. Interestingly, the type system can be significantly simplified by backwards type analysis. In this paper, a type and effect system for backwards type analysis and a corresponding type soundness result are presented. We first give a brief summary of Creol’s concurrency and communication model. An object in Creol may be understood as an encapsulated state on which various processes are executed. A process corresponds to the activation of one of the object’s methods. Objects are