Showing papers on "Concurrent object-oriented programming published in 1986"

Actors: A Model of Concurrent Computation in Distributed Systems

Abstract: : A foundational model of concurrency is developed in this thesis. It examines issues in the design of parallel systems and show why the actor model is suitable for exploiting large-scale parallelism. Concurrency in actors is constrained only by the availability of hardware resources and by the logical dependence inherent in the computation. Unlike dataflow and functional programming, however, actors are dynamically reconfigurable and can model shared resources with changing local state. Concurrency is spawned in actors using asynchronous message-passing, pipelining, and the dynamic creation of actors. The author defines an abstract actor machine and provide a minimal programming language for it. A more expressive language, which includes higher level constructs such as delayed and eager evaluation, can be defined in terms of the primitives. Examples are given to illustrate the ease with which concurrent data and control structures can be programmed. This thesis deals with some central issues in distributed computing. Specifically, problems of divergence and deadlock are addressed. Additional keywords: Object oriented programming; Semantics.

Visual programming, programming by example, and program visualization: a taxonomy

Abstract: There has been a great interest recently in systems that use graphics to aid in the programming, debugging, and understanding of computer programs. The terms “Visual Programming” and “Program Visualization” have been applied to these systems. Also, there has been a renewed interest in using examples to help alleviate the complexity of programming. This technique is called “Programming by Example.” This paper attempts to provide more meaning to these terms by giving precise definitions, and then uses these definitions to classify existing systems into a taxonomy. A number of common unsolved problems with most of these systems are also listed.

Concurrent Prolog: A Progress Report

Abstract: Concurrent Prolog is a logic programming language designed for concurrent programming and parallel execution. It is a process oriented language, which embodies dataflow synchronization and guarded-command indeterminacy as its basic control mechanisms.

Para-functional programming: a paradigm for programming multiprocessor systems

Abstract: One of the most important pragmatic advantages of functional languages is that concurrency in a program is implicit -- there is no need for special constructs to express parallelism as is required in most conventional languages. Furthermore, it is fairly easy for compilers to automatically determine the concurrency as a step toward decomposing a program for execution on a suitable parallel architecture. Yet it is often the case that one knows precisely the optimal decomposition for execution on a particular machine, and one can never expect a compiler to determine such optimal mappings in all cases. This paper is concerned with ways to allow the programmer to explicitly express this mapping of program to machine, by using annotations that, given a few minor constraints, cannot alter the functional semantics of the program. We show through several detailed examples the expressiveness and conciseness of the resulting "para-functional" programming methodology, using an experimental language called ParAlfl based on our ideas. We also give a formal denotational description of the mapping semantics using a notion of execution trees.This research was supported in part by NSF Grants DCR-8403304 and DCR-8451415, and a Faculty Development Award from IBM.

Merging objects and logic programming: relational semantics

Abstract: This paper proposes new semantics for merging object programming into logic programming. It differs from previous attempts in that it takes a relational view of method evaluation and inheritance mechanisms originating from object programming. A tight integration is presented, an extended rationale for adopting a success/failure semantics of backtrackable methods calls and for authorizing variable object calls is given. New method types dealing with non monotonicity and determinism necessary for this tight integration are discussed. The need for higher functions is justified from a user point of view. as well as from an implementation one. The system POL is only a piece of a more ambitious goal which is to merge logic programming, object programming and semantic data models which can be seen as an attempt to bridge the gap between Al and databases. The paper is restricted to a programming perspective.

Objects in concurrent logic programming languages

Abstract: Concurrent Prolog supports object-oriented programming with a clean semantics and additional programming constructs such as incomplete messages, unification, direct broadcasting, and concurrency synchronization [Shapiro 1983a]. While it provides excellent computational support, we claim it does not provide good notation for expressing the abstractions of object-oriented programming. We describe a preprocessor that remedies this problem. The resulting language, Vulcan, is then used as a behicle for exploring new variants of object-oriented programming which become possible in this framework.

The design and implementation of Concurrent Smalltalk

Abstract: ConcurrentSmalltalk is a programming language/system which incorporates the facilities of concurrent programming in Smalltalk-801. Such facilities are realized by providing concurrent constructs and atomic objects. This paper first gives an outline of ConcurrentSmalltalk. Then, the design of ConcurrentSmalltalk is described. The implementation of ConcurrentSmalltalk is presented in detail.

Flexible software development for multiple computer systems

Abstract: The authors develop a model of concurrent software and the associated programming tools that jointly permit flexible software development for experimental programming on the Cm* multiprocessor. The model's implementation in the TASK and Bliss-11 programming languages is described using a sample concurrent program.

Current Trends in Concurrency: Overviews and Tutorials

Abstract: Computer science in industry.- Dataflow and education: Data-driven and demand-driven distributed computation.- Contrasting themes in the semantics of imperative concurrency.- Functional programming and the language tale.- Design, specification and validation of hierarchies of protocols in distributed systems.- Infinitary languages: Basic theory and applications to concurrent systems.- The quest goes on: A survey of proofsystems for partial correctness of CSP.- Logic programming: The foundations, the approach and the role of concurrency.- Process theory: Semantics, specification and verification.- Applications of temporal logic to the specification and verification of reactive systems: A survey of current trends.- Petri nets: Basic notions, structure, behaviour.- Concepts for concurrent programming.

Programming for observability support in a parallel programming environment

Abstract: The programming for observability concept for performance/correctness debugging in a parallel programming environment is introduced. The design, first implementation, and evaluation of the required language and system support is presented. A two dimensional, multilevel, integrated monitoring system is described. Distinction is made between the monitoring mechanism, monitoring policies and their implementation tradeoffs. PIEMON-1, an initial implementation of the presented design is outlined and evaluated.

Logic programming: the foundations, the approach and the role of concurrency

Abstract: This paper is an introduction to the problem of defining the semantics of concurrency in logic programming. The standard semantics of logic programming languages is treated in the first two sections. The unique features of logic programming are then discussed on some examples in typical applications areas. The process interpretation of logic programs and some parallel operational models are considered next. Finally, concurrent logic languages are introduced, by discussing some examples in Concurrent Prolog and the semantics of two relevant mechanisms of concurrent logic languages, i.e. perpetual processes and read-only variables.

An extension of the language C for concurrent programming

Abstract: C is a well-known language for systems programming in UNIX-systems. Its concepts are very efficient rather than very safe and, therefore, an extension of C for concurrent programming has also to focus on an efficient implementation instead of on very safe programming concepts. We will present processes, modified ports, and modified signals as concepts for extending C. These concepts are defined close to hardware structures as mailboxes and interrupts and, therefore, they can be implemented efficiently. On the other hand we will show that many classical concepts of concurrent programming can be simulated by ports and signals and, therefore, these primitives are sufficiently powerful.