Distributed Programming Language Research Articles

Nomadic pict

This paper addresses the design and verification of infrastructure for mobile computation. In particular, we study language primitives for communication between mobile agents. They can be classi ed into two groups. At a low level there are location dependent primitives that require a programmer to know the current site of a mobile agent in order to communicate with it. At a high level there are location independent primitives that allow communication with a mobile agent irrespective of any migrations. Implementation of the high level requires delicate distributed infrastructure algorithms. In earlier work with Wojciechowski and Pierce we made the two levels precise as process calculi, allowing such algorithms to be expressed as encodings of the high level into the low level; we built NOMADIC PICT, a distributed programming language for experimenting with such encodings. In this paper we turn to semantics, giving a de nition of the core language and proving correctness of an example infrastructure. This requires novel techniques: we develop equivalences that take migration into account, and reasoning principles for agents that are temporarily immobile (eg. waiting on a lock elsewhere in the system).

Nomadic Pict: language and infrastructure design for mobile agents

Location-independent communication between migrating agents requires a distributed infrastructure. The authors describe their Nomadic Pict distributed programming language and use it to develop an infrastructure for an example application.

EXPLORATORY PROGRAMMING OF DISTRIBUTED 3D GRAPHICS APPLICATIONS

Repo-3D is a general-purpose, object-oriented library for developing distributed, interactive 3D graphics applications across a range of heterogeneous workstations. In this paper we discuss how Repo-3D simplifies exploratory programming of distributed 3D graphical applications, making it easy for programmers to rapidly evolve prototypes using a familiar multi-threaded, object-oriented programming paradigm. All data sharing of both graphical and non-graphical data is done via general-purpose distributed objects, presenting the illusion of a single distributed shared memory. Repo-3D is embedded in Repo, an interpreted, lexically-scoped, distributed programming language, allowing entire applications to be rapidly prototyped. We discuss Repo-3Di?½s design and how it supports exploratory distributed programming, present a number of illustrative examples, and discuss the pros and cons of this model for other programming tasks.

Distributed System Design

Jie Wu CRC Press Publishing Company, Boca Raton, FL, 1998, 496 pp. ISBN 0-8493-3178-1, $74.95 The Distributed System Design is a superbly organized, comprehensive exposition of basic concepts, issues, and some possible solutions in the distributed systems design. Highly regarded author has meticulously selected the material from original sources of contemporary literature, new contributed papers by preeminent researchers in the field plus his own research results to provide state-of-the-art discussions on various important issues in distributed systems design. Graduate/senior undergraduate students in distributed systems design/advanced operating systems as well as computer professionals analyzing and designing distributed/open/parallel systems will find key insights into current trends and solutions of distributed systems likely to shape future directions of this important field. From the beginning, the author motivates the study of this subject well by pointing out that the future requirements for computing speed, system reliability, and cost-effectiveness entail the development of alternative computers to replace the traditional von Neumann organization. As computing networks come into being, one of the latest dreams is now possible—distributed computing. The twelve chapters of this book can be roughly divided into three parts. Part I (Chapters 1 to 3) introduces the necessary background material and foundations in the aspect of distributed system model, distributed programming languages and formal approaches to distributed systems design. The background material is comprehensive and the model that the author uses throughout the book is emphasized. This part gives the reader a perspective on past accomplishments and a global picture of the area. Part II (Chapters 4 to 11) addresses various important issues in distributed systems design such as mutual exclusion, deadlock, interprocessor communication mechanisms, reliability issue, static and dynamic load distribution and distributed data management. Each chapter concentrates on software elements of design that emphasize performance, flexibility, fault tolerance, and scalability. Each issue is put forward clearly by descriptions and diagrams. Possible solutions are presented with algorithms and explicit examples. Ample references are provided for further exploration of the issues. This part is beneficial to students/researchers on their research projects in distributed systems. Part III (Chapter 12) concentrates on the applications of distributed design in operating systems, file systems, shared memory systems, database systems and heterogeneous processing, which further demonstrate the significance of distributed systems. In addition, future research directions are listed that provide readers with the trend in this field. The exercises after each chapter are original, challenging and pertaining to the content just covered. They have a nice mix of theory, analysis, and design, which not only help readers refresh their knowledge but also widen their view scope of this subject. In summary, this book is a well-organized and thoroughly developed text with plenty of current issues and research results in distributed systems explained in supportive examples and illustrations. The major sections of the book are well ordered, as is each individual chapter. In a word, with a level of expertise simply unmatched in the field, Distributed System Design provides readers with a solid foundation to understand and further explore in this increasingly important area of technology. Xiao Chen Southwest Texas State University

Development of an atomic-broadcast protocol using LOTOS

In this article we report on the development of a group-communication service using the formal specification language LOTOS, and present our experience in using publicly available tools for this purpose. The service implements atomic broadcast through a Two-Phase-Commit protocol, providing at-least-once delivery semantics and with no restriction on message delivery order. First we wrote an informal specification describing the desired properties from the service, the interfaces with the underlying network layer and the upper user layer, and the protocol to be used by the service. Then we developed the formal specification of the protocol in LOTOS. After validating the formal specification and thus having a certain confidence in its adequacy with respect to the informal specification, we derived test cases from the formal specification and implemented the service using the Concert/C distributed programming language. While testing the implementation, we found that most errors were related to unspecified features or bugs in the execution environment. From this experience, we draw our conclusions on the usefulness of software development based on formal techniques. Copyright © 1999 John Wiley & Sons, Ltd.

LVT: a layered verification technique for distributed computing systems

This paper presents a layered verification technique, called LVT, for the verification of distributed computing systems with multiple component layers. Each lower layer in such a system provides services in support of functionality of the higher layer. By taking a very general view of programming languages as interfaces of systems, LVT treats each layer in a distributed computing system as a distributed programming language. Each relatively higher-level language in the computing system is implemented in terms of a lower-level language. The verification of each layer in a distributed computing system can then be viewed as the verification of implementation correctness for a distributed language. This paper also presents the application of LVT to the verification of a distributed computing system, which has three layers: a small high-level distributed programming language; a multiple processor architecture consisting of an instruction set and system calls for inter-process message passing; and a network interface. Programs in the high-level language are implemented by a compiler mapping from the language layer to the multiprocessor layer. System calls are implemented by network services. LVT and its application demonstrate that the correct execution of a distributed program, most notably its inter-process communication, is verifiable through layers. The verified layers guarantee the correctness of (1) the compiled code that makes reference to operating system calls, (2) the operating system calls in terms of network calls, and (3) the network calls in terms of network transmission steps. The specification and verification involved are carried out by using the Cambridge Higher Order Logic (HOL) theorem proving system. Copyright © 1999 John Wiley & Sons, Ltd.

Proof-theoretic foundations for the design of actor systems

The pioneering work of Hewitt and Baker on the foundations of concurrency during the seventies has inspired the development of the actor model as a promising object-based framework for understanding open distributed systems. So far, theoretical research on actors has focused on identifying the basic primitives of the model and on characterising the operational behaviour of distributed programming languages in terms of actor components. In this paper, we show that the actor model can also be used as a faithful basis for rigorously designing open distributed systems. We argue that a proof-theoretic approach is better suited to this purpose. An abstract-data-type-like axiomatisation of the actor primitives is proposed to support composing and reasoning from specifications of actor communities within a temporal logical system.

Formal verification of a programming logic for a distributed programming language

This paper presents a method for mechanically proving the soundness of a programming logic for a distributed programming language, in support of the development of verified program verification tools. We focus on: 1. (1) how to formalize the operational semantics of a distributed programming language; 2. (2) how to formalize the concept of program correctness for distributed programs; 3. (3) how to mechanically prove the soundness of a programming logic with respect to the formal semantics of the language; 4. (4) how to use the mechanized and sound logic to develop verification tools with soundness guaranteed; and 5. (5) how to accomplish all above in the same formalism. Our programming logic permits the verification of single processes executing in isolation and, also, the verification of the composition of concurrently executing processes. Our method demonstrates that structuring the specification of operational semantics can ease the creation of a sound and mechanized programming logic for distributed programming languages. We believe that our method can be scaled up to larger distributed programming languages and their programming logics. The Cambridge HOL theorem proving system is used in our research.

A new generalized software complexity metric for distributed programs

With increasing complication in distributed programs we must do our best to establish the mechanism of maintaining distributed programs. This paper introduces the notion of the communication complexity unit based on the smallest event communication group, and presents a generalized software complexity metric for measuring the maintenance complexity of distributed programs. We affirm that the smallest event communication group is a unifying mechanism for event and process abstraction whatever distributed programming languages are used and advocate it as a basically generalized communication complexity unit. We have applied the proposed distributed software complexity metric to a moderately complex example. Experience indicates that the proposed metric is indeed very useful.

Why networks aren't programmable (or, why programs aren't protocols)

For 25 years now, since the early work on RPC in the early years of the Arpanet, computer scientists have devised programming languages that would simplify the design and implementation of distributed applications. Yet today the phenomenally successful Internet employs simple text-based protocols (HTTP, SMTP, etc.) and the phenomenally successful Java programming language relegates RPC to a library (RMI).Why aren't we using distributed programming languages to develop distributed applications? The reasons are both technical and commercial. This talk will discuss the commercial trends in distributing computing and identify some of the technical obstacles to the commercial application of distributing programming techniques.

A comprehensive study of the complexity of multiparty interaction

A multiparty interaction is a set of I/O actions executed jointly by a number of processes, each of which must be ready to execute its own action for any of the actions in the set to occur. An attempt to participate in an interaction delays a process until all other participants are available. Although a relatively new concept, the multiparty interaction has found its way into a number of distributed programming languages and algebraic models of concurrency. In this paper, we present a taxonomy of languages for multiparty interaction that covers all proposals of which we are aware. Based on this taxonomy, we then present a comprehensive analysis of the computational complexity of the multiparty interaction scheduling problem, the problem of scheduling multiparty interactions in a given execution environment.

Object and native code thread mobility among heterogeneous computers

We present a technique for moving objects and threads among heterogeneous computers at the native code level. To enable mobility of threads running native code. we convert thread states among machine-dependent and machine-independent formats. We introduce the concept of bus stops, which are machine-independent representations of program points as represented by program counter values. The concept of bus stops can be used also for other purposes. e.g. to aid inspecting and debugging optimized code, garbage collection etc. We also discuss techniques for thread mobility among processors executing differently optimized codes. We demonstrate the viability of our ideas by providing a prototype implementation of object and thread mobility among heterogeneous computers. The prototype uses the Emerald distributed programming language without modification ; we have merely extended the Emerald runtime system and the code generator of the Emerald compiler. Our extensions allow object and thread mobility among VAX, Sun-3, HP9000/300, and Sun SPARC workstations. The excellent intra-node performance of the original homogeneous Emerald is retained : migrated threads run at native code speed before and after migration ; the same speed as on homogeneous Emerald and close to C code performance. Our implementation of mobility has not been optimized : thread mobility and trans-architecture invocations take about 60% longer than in the homogeneous implementation. We believe this is the first implementation of full object and thread mobility among heterogeneous computers with threads executing native code.

Programming language support for writing fault-tolerant distributed software

Good programming language support can simplify the task of writing fault-tolerant distributed software. Here, an approach to providing such support is described in which a general high-level distributed programming language is augmented with mechanisms for fault tolerance. Unlike approaches based on sequential languages or specialized languages oriented towards a given fault-tolerance technique, this approach gives the programmer a high level of abstraction, while still maintaining flexibility and execution efficiency. The paper first describes a programming model that captures the important characteristics that should be supported by a programming language of this type. It then presents a realization of this approach in the form of FT-SR, a programming language that augments the SR distributed programming language with features for replication, recovery, and failure notification. In addition to outlining these extensions, an example program consisting of a data manager and its associated stable storage is given. Finally, an implementation of the language that uses the x-kernel and runs standalone on a network of Sun workstations is discussed. The overall structure and several of the algorithms used in the runtime are interesting in their own right.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Source—A debugging tool for ParMod

Debugging parallel and distributed programs is much more difficult than debugging sequential programs. The main reasons for this fact are the missing reproducability of parallel programs, the added complexity because of more threads of control, and the great importance of the probe effect because of time dependencies in parallel programs. This paper shows how the problems mentioned above are handled in the debugger Source for the parallel and distributed programming language ParMod.

Compositional priority specification in real-time distributed systems

In this paper, we develop a compositional denotational semantics for prioritized real-time distributed programming languages. One of the interesting features is that it extends the existing compositional theory proposed by Koymanset al (1988) for prioritized real-time languages preserving the compositionality of the semantics. The language permits users to define situations in which an action has priority over another action without the requirement of preassigning priorities to actions for partially ordering the alphabet of actions. These features are part of the languages such as Ada designed specifically keeping in view the needs of real-time embedded systems. Further, the approach does not have the restriction of other approaches such as prioritized internal moves can pre-empt unprioritized actions etc. Our notion of priority in the environment is based on the intuition that a low priority action can proceed only if the high priority action cannot proceed due to lack of the handshaking partner at that point of execution. In other words, if some action is possible corresponding to that environment at some point of execution then the action takes place without unnecessary waiting. The proposed semantic theory provides a clear distinction between the semantic model and the execution model — this has enabled us to fully ensure that there is no unnecessary waiting.

Pollux: A language for distributed system programming

The objective of the Pollux project was to create a programming language suitable for education (the Distributed Systems classes) and for programming of small distributed applications. The Pollux language is based on the Remote Procedure Call concept. Agents, that are communicating atomic units of parallelism, may be created dynamically.

The Lynx distributed programming language: Motivation, design and experience

A programming language can provide much better support for interprocess communication than a library package can. Most message-passing languages limit this support to communication between the pieces of a single program, but this need not be the case. Lynx facilitates convenient, typesafe message passing not only within applications, but also between applications and among distributed collections of servers. Specifically, it addresses issues of compiler statelessness, late binding, and protection that allow run-time interaction between processes that were developed independently and that do not trust each other. Implementation experience with Lynx has yielded important insights into the relationship between distributed operating systems and language run-time support packages and into the inherent costs of high-level message-passing semantics.

Static analysis of real-time distributed systems

A static analysis for reasoning about the temporal behaviors of programs in real-time distributed programming languages is proposed. The analysis is based on the action set semantics using the pure maximal parallelism model. It is shown how to specify and verify various timing properties of real-time programs. The approach provides only an approximate timing behavior, because the state information is ignored. However, many interesting properties such as parallel actions, deadlocks, livelocks, terminations, temporal errors, and failures, can be identified. Furthermore, the approach is compositional and thus makes it possible to reason about the timing properties incrementally. The method not only leads to efficient algorithms for the static analysis of CSP programs but also applies to many other languages.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Integrating Emerald into a system for mixed-language programming

The difficulties encountered while resolving the programming models of object-oriented and procedure-oriented languages are discussed. As a concrete example, the integration of Emerald—an object-oriented, distributed programming language—into the MLP system for mixed-language programming is described. This integration allows Emerald objects to invoke procedures written in other supported languages, and allows procedures written in the other languages to invoke operations on Emerald objects. Two different aspects of this integration are highlighted. First, the issues involved in bridging the distance between the programming model supported by Emerald and the programming model supported by MLP are discussed; specific problems include reconciling the object-oriented nature of Emerald with the procedure-oriented model of MLP, and accommodating Emerald's concurrency within the previously sequential MLP system. Second, the implementation of this design is described.

Programming languages for distributed computing systems

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.