Objective ML is a small practical extension to ML with objects and top level classes. It is fully compatible with ML; its type system is based on ML polymorphism, record types with polymorphic access, and a better treatment of type abbreviations. Objective ML allows for most features of object-oriented languages including multiple inheritance, methods returning self and binary methods as well as parametric classes. This demonstrates that objects can be added to strongly typed languages based on ML polymorphism.

Process algebras are often advocated as suitable formalisms for the specification of telecommunication protocols and distributed systems. However, despite their mathematical basis, despite standardization attempts (most notably the Formal Description Technique Lotos), and despite an ever growing number of successful case-studies, process algebras have not yet reached a wide acceptance in industry. On the other hand, description languages such as Promela or Sdl are quite popular, although they lack a formal semantics, which should prohibit their use for safety-critical systems. In this paper, we seek to merge the "best of both worlds" by attempting to define a "second generation Formal Description Technique" that would combine the strong theoretical foundations of process algebras with language features suitable for a wider industrial dissemination of formal methods. Taking the international standard Lotos as a basis, we suggest several enhancements, which fall into three ...

We show how classes can be combined with a ML-like module system, so that the same constructions be used for both classes and modules. For that, we are brought to slightly extend the module system with implicit type quantification of module types. Introduction Classes and modules shares a lot of properties: they offer some form of abstraction; they structure the code and facilitate its reuse. Due to this overlapping of functionalities, it is sometimes difficult in a language providing both constructions to make a choice between them. This paper attempts to reduce the gap between these two styles of programming by merging classes and modules: we show how the classes of Objective ML [5] can be encoded as modules. This requires a small but natural extension to existing ML-like module systems: just as ML types are implicitly quantified, we propose that module types be also implicitly quantified over some type variables. We of course also make some specific additions to the module language...

This paper discusses a load balancing technique for distributed processing systems in which the load may vary over a wide range and at a high rate. Each processor performs a source or server algorithm for migrating processes when its load crosses some assigned upper or lower bound; these bounds are dynamically adjusted. Taking into account the speed at which loads vary and the latency of the underlying network, we specify conditions under which the algorithm is stable and responds satisfactorily to fast load changes. Simulation confirms the validity of these conditions.

. The idea of making synchronous operations into first-class values is an important one for supporting abstraction and modularity in concurrent programs. This design principle has been used with great success in the concurrent language CML, but what are the limitations of this approach? This paper explains the rationale for first-class synchronous operations, and discusses their use in CML. It also presents some recent and fundamental results about the expressiveness of rendezvous primitives, which define the limitations of synchronous abstractions. 1 Introduction Abstraction is a key tool for managing complexity. The design of programming languages is one area where application of this idea has paid significant dividends. Languages have evolved from providing a fixed set of abstractions of the underlying hardware, such as arithmetic expressions and arrays, to providing support for programmer-defined abstractions, such as abstract data-types and higher-order procedures. By providing ...

In this paper we present a scheme for maintaining coherency between copies of objects in a distributed system. Instead of using a fixed protocol for all objects and all time, our scheme is adaptive and is able to select the best from among a set of three protocols. The protocol is selected for each object and may change over time if the pattern of accesses to that object changes. The scheme is in the process of being implemented as part of a distributed shared memory system for ML-like languages. We give a simulation of an example which demonstrates that between 30 and 40 per cent of messages can be saved by our scheme, compared with the dynamic distributed manager algorithm of Kai Li [LH89]. Key words: Distributed shared memory, adaptive algorithm, concurrent functional languages. 1

Recently the use of formal methods in describing and analysing the behaviour of (computer) systems has become more common. This has resulted in the proliferation of a wide variety of different specification formalisms, together with analytical techniques and methodologies for specification development. The particular specification formalism adopted for this study is LOTOS, an ISO standard formal description technique. Although there are many works dealing with how to write LOTOS specifications and how to develop a LOTOS specification from the initial abstract requirements specification to concrete implementation, relatively few works are concerned with the problems of expressing and proving the correctness of LOTOS specifications, i.e. verification. The main objective of this thesis is to address this shortfall by investigating the meaning of verification as it relates to concurrent systems in general, and in particular to those systems described using LOTOS. Further goals are to autom...

LCS is an experimental high level parallel programming language aimed at exploring design, implementation and use of programming languages based upon process calculi. LCS extends Standard ML with primitives for concurrency and communication based upon a higher order extension of the CCS formalism. The paper discusses language design, illustrates programming disciplines, and investigates abstract machines for sequential and parallel implementations of the language.

this paper we consider inda, a concurrent applicative language based on a rather different concurrency paradigm, namely the Linda concept of Gelernter and Bernstein [GB82], and give a type system where effects are described by expressions in a process calculus. The type inference system proposed in this paper introduces a novel combination of two previous solutions that have been used to deal with a problem peculiar to applicative programming languages, that of determining the polymorphic effect type of functions. Should one use subtyping or effect polymorphism? We argue that a combination is needed. We give a sound type reconstruction algorithm based around our idea. Proofs of all results stated in the paper are found in [KJH94]. 2 inda

and Record Types Didier R'emy INRIA-Rocquencourt, BP 105, F-78153 Le Chesnay Cedex. To appear in TACS'94 Abstract. Class-based objects can be programmed directly and efficiently in a simple extension to ML. The representation of objects, based on abstract and record types, allows all usual operations such as multiple inheritance, object returning capability, and message transmission to themselves as well as to their super classes. There is, however, no implicit coercion from objects to corresponding ones of super-classes. A simpler representation of objects without recursion on values is also described. The underlying language extends ML with recursive types, existential and universal types, and mutable extensible records. The language ML-ART is given with a call-by-value semantics for which type soundness is proved. Introduction An important motivator for type-checking extensible records is their application to object encoding. Initiated by Cardelli in 1984 [Car84], c...