The π-calculus offers an attractive basis for concurrent programming. It is small, elegant, and well studied, and supports (via simple encodings) a wide range of high-level constructs including data structures, higher-order functional programming, concurrent control structures, and objects. Moreover, familiar type systems for the -calculus have direct counterparts in the π-calculus, yielding strong, static typing for a high-level language using the π-calculus as its core. This paper describes Pict, a strongly-typed concurrent programming language constructed in terms of an explicitly-typed-calculus core language.

Abstract not found

The theory of cut-free sequent proofs has been used to motivate and justify the design of a number of logic programming languages. Two such languages, λProlog and its linear logic refinement, Lolli [15], provide for various forms of abstraction (modules, abstract data types, and higher-order programming) but lack primitives for concurrency. The logic programming language, LO (Linear Objects) [2] provides some primitives for concurrency but lacks abstraction mechanisms. In this paper we present Forum, a logic programming presentation of all of linear logic that modularly extends λProlog, Lolli, and LO. Forum, therefore, allows specifications to incorporate both abstractions and concurrency. To illustrate the new expressive strengths of Forum, we specify in it a sequent calculus proof system and the operational semantics of a programming language that incorporates references and concurrency. We also show that the meta theory of linear logic can be used to prove properties of the objectlanguages specified in Forum.

Static typing and subtyping are useful for the support of incremental refinement and reuse in object-oriented languages. Although demanded, there is currently no appropriate type model for concurrent object-oriented languages that supports dynamic behavior modifications. We propose a type model based on a process calculus with trace semantics and demonstrate its use in a simple language. This model is an extension of conventional models for types and subtyping and ensures that all messages are processed even if object behavior is modified dynamically. Keywords type model, subtyping, concurrency, process algebra 1 INTRODUCTION The object-oriented paradigm is now probably the most important paradigm for the development of software. Object-oriented programming languages are based on objects communicating with other objects by exchanging messages (Wegner, 1990). An object is a self-contained entity characterized by its identity, state and behavior. The objects are classified according to...

An object's type is usually regarded as a contract between the object and each of its users. However, in concurrent (and sometimes also in sequential) systems it is more useful to regard a type as a contract between an object and the unity of all users; the users must be coordinated before sending messages to the object. Types in the proposed model express requirements on the coordination of users; objects must accept messages only in prespecified orderings. The model ensures statically that objects behave as specified by their types and users are coordinated appropriately. Keywords: Type model, concurrency, active objects. 1 Introduction Each expression written in a statically typed programming language has a unique type specified explicitly or derivable at compile-time. Strong typing ensures that violations of type constraints (type errors) cannot occur during program execution [3]. Static and strong typing may increase the readability and reliability of programs and support optimi...

In this paper we enhance the SOFAComponent Description Language with a semantic description of a component's functionality. There are two key requirements this description aims to address: First, for the design purpose, it should ensure correct composition of the nested architectural abstractions; second, it should be easy-to-read so that an average user can identify a component with the correct semantics for the purposes of component trading. The semantic description in SOFA expresses the behavior of the component in terms of behavior protocols using a notation similar to regular expressions which is easy-to-read, and which grants guarantees about required and provided services. The behavior protocols are used on three levels: interface, frame, and architecture. One of the key achievements of this paper is that it defines a protocol conformance relation where the component designer can statically verify that the frame protocol adheres to requirements of the interface protoco...

Object-oriented software development is characterized by the repeated refinement of specifications and software components. The refinement of specifications is facilitated by the use of specification languages which support subtyping based on the principle of substitutability. In this paper we propose to specify concurrent systems by types represented as expressions of a process calculus. These types allow to specify also dynamic language aspects and still support subtyping and static type-checking. Keywords type specification, subtyping, static type checking, process calculi 1 INTRODUCTION Specifications have long been a cornerstone in the development of reliable software and will continue to receive much attention if there are appropriate specification techniques that can be adapted to the characteristics of the specified software and the software development process. The current trend in software development follows the object-oriented paradigm characterized by a hierarchical clas...

Subtyping is undoubtedly useful for the support of incremental refinement and reuse of software components, a crucial feature of object-oriented languages. Types and subtyping for concurrent languages are not yet explored sufficiently and tend to be less flexible than desired. We propose a principle of dealing with very flexible types in concurrent languages. The corresponding type model ensures that "message not understood " errors cannot occur even if object behavior can be dynamically modified in some ways. 1 Introduction The basic concept of object-oriented programming languages is that of objects communicating with other objects [4, 17]. An object is a self-contained entity characterized by its identity, state and behavior. The objects are classified according to their behavior into a system of types. We regard also subtyping [5, 10] and the related sort of polymorphism (inclusion polymorphism) as necessary features of object-oriented languages. In concurrent object-oriented lan...

bejleri @ cli.di.unipi.it

We propose a typed, higher-order, concurrent linear logic programming called higher-order ACL, which uniformly integrates a variety of mechanisms for concurrent computation based on asynchronous message passing. Higher-order ACL is based on a proof search paradigm according to the principle, proofs as computations, formulas as processes in linear logic. In higher-order ACL, processes as well as functions, and other values can be communicated via messages, which provides high modularity of concurrent programs. Higher-order ACL can be viewed as an asynchronous counterpart of Milner's higher-order, polyadic ß-calculus. Moreover, higher-order ACL is equipped with an elegant ML-style type system that ensures (1) well typed programs can never cause type mismatch errors, and (2) there is a type inference algorithm which computes a most general typing for an untyped term. We also demonstrate a power of higher-order ACL by showing several examples of "higher-order concurrent programming." ANY O...