Based on a name-passing calculus and on its typing system the paper shows how to build several language constructors towards a strongly-typed objectoriented concurrent programming language. The basic calculus incorporates the notions of asynchronous labelled messages, concurrent objects composed of labelled methods, and a form of abstraction on processes allowing in particular to declare polymorphic classes. We introduce a notion of values as name-expressions, and show how to create subclasses of existing classes. A systematic translation of the derived constructors into the basic calculus provides for semantics and for typing rules for the new constructors. Introduction Concurrent objects constitute a convenient tool to describe concurrent and distributed computations. Types enforce a discipline in the usage of the programming language constructors that not only provides for partial-correctness, but also helps in writing clear programs. Furthermore, a type for a program often gives s...

The present paper introduces an implicitly typed object calculus intended to capture intrinsic aspects of concurrent objects communicating via asynchronous message passing, together with a typing system assigning typings to terms in the calculus. Types meant to describe the kind of messages an object may receive are assigned to the free names in a program, resulting in a scenario where a program is assigned multiple name-type pairs, constituting a typing for the process. Programs that comply to the typing discipline are shown not to suffer from runtime errors. Furthermore the calculus possesses a notion of principal typings, from which all typings that make a program well-typed can be extracted. We present an efficient algorithm to extract the principal typing of a process. 1 Introduction Most of the attempts to introduce some type discipline into object-oriented languages start from lambda-calculus, by extending this with some kind of records. There are several limitations to this ap...

We adapt the Damas-Milner typing discipline to the join-calculus. The main result is a new generalization criterion that extends the polymorphism of ML to join-definitions. We prove the correctness of our typing rules with regard to a chemical semantics. We also relate typed extensions of the core join-calculus to functional languages. 1 Introduction The distributed implementation of concurrent calculi with message passing raises the problem of implementing communication channels, which finally reduces to the specification of channel managers. In order to reflect this need in the language itself, a new formalism has been recently introduced : the join-calculus [2]. This calculus is similar to Milner's asynchronous ß-calculus, except that the operations of restriction, reception and replication are all combined into a single receptor definition. Such a combination yields better control over communication. In [2, 3], we relied on this locality property to model realistic distributed sys...

There has been an ever growing interest in the study of process-calculi as frameworks for concurrent, distributed, object-oriented languages. These are of particular importance given the adequacy of the object programming model and its widespread use in software development and, ultimately, in Internet applications. The asynchronous - calculus is a powerful tool to reason about concurrent process interaction. However, it is not an adequate framework for the implementation of object-oriented languages as its encodings of objects are quite inefficient. Efforts in the implementation of languages based on process calculi have so far failed in providing a unifying framework in the form of a virtual machine specification. This thesis introduces a virtual machine specification and its implementation for a variant of the -calculus -- the TyCO calculus. TyCO features objects and asynchronous messages. Thus, contrary to other calculi such as , objects are builtin entities and do not require computa...

We propose a programming model for distributed concurrent systems with mobile objects in the context of a process calculus. Code mobility is induced by lexical scoping on names. Objects and messages migrate towards the site where their prefixes are lexically bound. Class definitions, on the other hand, are downloaded from the site where they are defined, and are instantiated locally upon arrival. We provide several programming examples to demonstrate the expressiveness of the model. Finally, based on this model we describe an architecture for a run-time system supporting concurrent, distributed computations and code mobility. Keywords: Distributed Computing, Process-Calculus, Concurrency, Code Mobility, Implementation. 1 Introduction Over the last few years, the increase in speed of both personal computers and network connections has fostered an ever growing research interest in distributed computing. Moreover, research on computation or code mobility has become one of the leading ed...

The aim of this thesis is to describe the semantics of a process calculus by means of hypergraph rewriting, creating a specification mechanism combining modularity of process calculi and locality of graph transformation. Verification of processes is addressed by presenting two methods: barbed congruence for relating processes displaying the same behaviour and generic type systems, forming a central part of this work. Based on existing work in graph rewriting...

We introduce a name-passing calculus featuring objects as guarded labelledsums, each summand representing a method, and asynchronous labelled messages selecting a branch in the sum. A decidable type assignment system allows to statically verify whether all possible communications in a given program are secure, in the precise sense that no object will ever receive a message for which it does not have an appropriate method. Then we present a recursive type system based on that of Cardone and Coppo for the -calculus, and of Vasconcelos and Honda for the polyadic -calculus. The new system extends the class of typable terms while preserving basic syntactical properties of the simple type system, including subject-reduction and existence and computability of principal typings. Introduction Object technologies are a promising paradigm towards the management of complex, concurrent, distributed and open-ended systems. Types are an acknowledged tool to describe protocols of communicat...

We present an operational semantics and a typing assignment system for the concurrent object-oriented specification language Gnome, based on a name-passing asynchronous calculus of concurrent objects, TyCO. The operational semantics is given by a map encoding Gnome classes in TyCO agents, and thus, objects (instances of classes) in processes (instances of agents). We propose a general approach to implement synchronous communication in an asynchronous process calculus, using a commit-abort protocol, achieving by this means the synchronization of all objects involved on a transaction. We treat objects with internal animation, their dynamic creation and deletion. Furthermore, the method generates a (decidable) typing assignment system that ensures lack of runtime errors for typable programs. The type of an agent certificates the communicating protocol of the corresponding class. 1 Introduction We aim at an operational semantics and a safe type system for a very high level concurrent obje...

. I propose an untyped name-passing calculus and a series of decidable type systems assigning types to names in terms. The calculus, designed according to the modern trends in name-passing calculi, is intended to capture the basic concepts of concurrent objects. The type systems, developed along the lines of those for -calculi, provide for partial-specification in the form of communication protocols for programs, and for partial-correctness wherein typable terms are assured not to run into errors at execution time. Terms are built from names and labels by means of five constructors, the innovations being guarded labelled-sums describing objects composed of labelled methods and asynchronous labelled messages selecting a method in the target object. The remaining constructors are fairly standard in name-passing calculi and comprise concurrent composition, local name creation (or scope restriction), and replication. The type systems assign types to names, and typings (that is, sets of nam...

this article appeared under the title "Typed Concurrent Objects"