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.

/pdf/programming-languages-for-distributed-computing-systems-swl2r5wnf8.pdf

Programming languages for distributed computing systems

Multimedia is defined as the integrated generation, representation, processing, storage, and dissemination of independent machine-processable information expressed in multiple time-dependent and time-independent media such as data, graphics, drawings, voice, audio, and video. The characteristics of synchronization mechanisms desirable for central and distributed multimedia systems are addressed. The concept of multimedia objects as components of an object-based model for a multimedia system is introduced. The essential new synchronization requirement is restricted blocking together with synchronization features covering real-time aspects. Existing synchronization mechanisms can be altered or new ones defined to meet these requirements. >

Synchronization properties in multimedia systems

We survey parallel programming models and languages using six criteria to assess their suitability for realistic portable parallel programming. We argue that an ideal model should by easy to program, should have a software development methodology, should be architecture-independent, should be easy to understand, should guarantee performance, and should provide accurate information about the cost of programs. These criteria reflect our belief that developments in parallelism must be driven by a parallel software industry based on portability and efficiency. We consider programming models in six categories, depending on the level of abstraction they provide. Those that are very abstract conceal even the presence of parallelism at the software level. Such models make software easy to build and port, but efficient and predictable performance is usually hard to achieve. At the other end of the spectrum, low-level models make all of the messy issues of parallel programming explicit (how many threads, how to place them, how to express communication, and how to schedule communication), so that software is hard to build and not very portable, but is usually efficient. Most recent models are near the center of this spectrum, exploring the best tradeoffs between expressiveness and performance. A few models have achieved both abstractness and efficiency. Both kinds of models raise the possibility of parallelism as part of the mainstream of computing.

/pdf/models-and-languages-for-parallel-computation-1sticvkm4u.pdf

Models and languages for parallel computation

The main problems associated with debugging concurrent programs are increased complexity, the "probe effect," nonrepeatability, and the lack of a synchronized global clock. The probe effect refers to the fact that any attempt to observe the behavior of a distributed system may change the behavior of that system. For some parallel programs, different executions with the same data will result in different results even without any attempt to observe the behavior. Even when the behavior can be observed, in many systems the lack of a synchronized global clock makes the results of the observation difficult to interpret. This paper discusses these and other problems related to debugging concurrent programs and presents a survey of current techniques used in debugging concurrent programs. Systems using three general techniques are described: traditional or breakpoint style debuggers, event monitoring systems, and static analysis systems. In addition, techniques for limiting, organizing, and displaying a large amount of data produced by the debugging systems are discussed.

Debugging concurrent programs

Concurrent programming is becoming increasingly important because multicomputers, particularly networks of microprocessors, are rapidly becoming attractive alternatives to traditional maxicomputers. Effective use of such network computers requires that programs be written with components that can be executed in parallel. The C programming language does not have concurrent programming facilities. Our objective is to enhance C so that it can be used to write concurrent programs that can run efficiently on both single computers and multicomputers. Our concurrent programming extensions to C are based on the rendezvous concept. These extensions include mechanisms for the declaration and creation of processes, for process synchronization and interaction, and for process termination and abortion. We give a rationale for our decisions and compare Concurrent C extensions with the concurrent programming facilities in Ada. Concurrent C has been implemented on the UNIX system running on a single processor. A distributed version of Concurrent C is being implemented.

W D Roome

Papers

Concurrent C