When distributed systems first appeared, they were programmed in traditional sequential languages, usually with the addition of a few library procedures for sending and receiving messages. As distributed applications became more commonplace and more sophisticated, this ad hoc approach became less satisfactory. Researchers all over the world began designing new programming languages specifically for implementing distributed applications. These languages and their history, their underlying principles, their design, and their use are the subject of this paper. We begin by giving our view of what a distributed system is, illustrating with examples to avoid confusion on this important and controversial point. We then describe the three main characteristics that distinguish distributed programming languages from traditional sequential languages, namely, how they deal with parallelism, communication, and partial failures. Finally, we discuss 15 representative distributed languages to give the flavor of each. These examples include languages based on message passing, rendezvous, remote procedure call, objects, and atomic transactions, as well as functional languages, logic languages, and distributed data structure languages. The paper concludes with a comprehensive bibliography listing over 200 papers on nearly 100 distributed programming languages.

The process of writing large parallel programs is complicated by the need to specify both the parallel behaviour of the program and the algorithm that is to be used to compute its result. This paper introduces evaluation strategies, lazy higher-order functions that control the parallel evaluation of non-strict functional languages. Using evaluation strategies, it is possible to achieve a clean separation between algorithmic and behavioural code. The result is enhanced clarity and shorter parallel programs. Evaluation strategies are a very general concept: this paper shows how they can be used to model a wide range of commonly used programming paradigms, including divideand -conquer, pipeline parallelism, producer/consumer parallelism, and data-oriented parallelism. Because they are based on unrestricted higher-order functions, they can also capture irregular parallel structures. Evaluation strategies are not just of theoretical interest: they have evolved out of our experience in parallelising several large-scale applications, where they have proved invaluable in helping to manage the complexities of parallel behaviour. These applications are described in detail here. The largest application we have studied to date, Lolita, is a 60,000 line natural language parser. Initial results show that for these applications we can achieve acceptable parallel performance, while incurring minimal overhead for using evaluation strategies.

The Gamma formalism is a programming model based on the nondeterministic rewriting of multisets. Programs in this formalism are expressed with a minimum of control, which makes the model very well-suited for writing parallel programs at a high level of abstraction. In the implementation, however, the chaotic behaviour of Gamma programs poses serious problems. To overcome these problems, we introduce a language that can be used to effectively control the nondeterministic behaviour. The control information is specified separately from the program text, which allows the logic of a program to be treated separately from control issues. Schedules for Multiset Transformer Programs May 19, 1995 2 1 Introduction The multiset transformer formalism (Gamma [1], [2]) provides a framework in which programs can be expressed with a minimum of (explicit) control. This absence of control is an advantage in the design phase because it allows programs to be expressed at a high level of abstraction wher...

this paper a general framework is described for the automatic generation of parallel programs based on a separately specified decomposition of the data. To this purpose, programs and data decompositions are expressed in a calculus, called Vcal. It is shown that by rewriting calculus expressions, Single Program Multiple Data (SPMD) code can be generated for shared-memory as well as distributed-memory parallel processors. Optimizations are derived for certain classes of access functions to data structures, subject to block, scatter, and block/scatter decompositions. The presented calculus and transformations are language independent. 1.

this paper, the language Booster is described. Booster is a high-level, fourth generation, parallel programming language. The language has been designed to program parallel algorithms for a wide variety of target parallel architectures. Booster has a strong separation of concerns, featuring amongst others a clear separation of algorithm description and algorithm decomposition and-representation. Programs written in Booster are translated to imperative languages, such as FORTRAN or C, and can be easily integrated in large applications. Parallelism can be obtained by applying data and/or code decomposition. Once algorithm and decomposition are described the transformation is done automatically

this paper we propose a new approach to the design of algorithms. This approach is based on the view that all algorithms are composed of a computation and a control component, and that these components can be designed separately. The computation component is responsible for the correctness of an algorithm. It embodies the computational knowledge about a problem domain that is needed to solve the corresponding problem. The control component governs complexity aspects of the solution method by directing the usage of the computational knowledge. This bisection allows the problem of how to construct an algorithm to be split into two smaller problems: "What are the elementary units of computational knowledge for the problem at hand?" and "In what order should these units be used to (efficiently) obtain a solution." This way, the concerns of correctness and complexity are separated. We assert that there are many advantages in separating correctness and complexity in algorithm design. Hence, we examine properties of programming formalisms that influence the possibility of separating the design of the computation and control components of an algorithm.

This paper describes a translation method for the automatic parallelization of programs based on a separately specified representation of the data. The method unifies the concept of data-representation on the algorithm-level as well as machine-level, based on the so-called view concept. It is shown that given a decomposition of the data, application of the translation method to the view-based Booster programming language results in efficient SPMD-code for distributed - as well as shared-memory architectures. It will be argued that the method is not restricted to Booster, but can also be applied to other languages.

This paper presents a compiling method to translate the functional programming language Valid into object code which is executable on a commercially available shared memory multiprocessor, Sequent Symmetry S2000. Since process management overhead in such a machine is very high, our compiling strategy is to exploit coarse-grain parallelism at function application level, and the function application level parallelism is implemented by a fork-join mechanism. The compiler translates Valid source programs into controlflow graphs based on dataflow analysis, and then serializes instructions within graphs according to flow arcs such that function applications, which have no data dependency, are executed in parallel. We report the results of performance evaluation of the compiled Valid programs on a Sequent S2000 and discuss the usefulness of our method by comparing it with C and SISAL compilers. 1 Introduction Many programming languages for parallel processing have been proposed recently. Amo...

Designing a programming model for distributed systems that is not too different from the programming model for sequential systems is a highly desired and challenging task. Of the programming languages for sequential systems, object oriented languages lend themselves rather easily to distributed extensions. In this thesis, the design and implementation of a distributed object oriented programming environment(VASTU) is described. VASTU is based on the object oriented programming language C++. Using the VASTU system, programmers can transparently create, access and destroy remote active objects. Active classes are specified using the VASTU ADL(Active Class Description Language). The compiler for this language generates C++ code that hides the details of distribution and provides a transparent interface to the clients. An object server runs on every machine in the system and is responsible for creating objects on that machine. Access to active objects is controlled using capabilities. The ...