# Concurrent Programming Using Actors: Exploiting large-Scale Parallelism

@inproceedings{Agha1985ConcurrentPU,
title={Concurrent Programming Using Actors: Exploiting large-Scale Parallelism},
author={Gul A. Agha and Carl E. Hewitt},
booktitle={Foundations of Software Technology and Theoretical Computer Science},
year={1985}
}
• Published in
Foundations of Software…
1 October 1985
• Computer Science
We argue that the ability to model shared objects with changing local states, dynamic reconfigurability, and inherent parallelism are desirable properties of any model of concurrency. The {\it actor model} addresses these issues in a uniform framework. This paper briefly describes the concurrent programming language {\it Act3} and the principles that have guided its development. {\it Act3} advances the state of the art in programming languages by combining the advantages of object-oriented…
109 Citations
• Hridesh Rajan
• Computer Science
2015 IEEE/ACM 37th IEEE International Conference on Software Engineering
• 2015
In a recently sponsored NSF project the authors are developing a model that they call capsule-oriented programming and its realization in the Panini project, which favors modularity over explicit concurrency, encourages concurrency correctness by construction, and exploits modular structure of programs to expose implicit concurrency.
• G. Agha
• Computer Science
OOPWORK '86
• 1986
The kernel of an actor language is presented and some of the higher-level control constructs are discussed and some advantages of actor languages in exploiting large-scale concurrent architectures are discussed.
• Computer Science
Programming Models for Massively Parallel Computers
• 1995
This paper investigates the suitability of parallel architectures for the realisation of a novel object-based computational model encapsulated within programming languages such as ConcurrentMeteteM, which provides a high-level architecture-independent representation for a variety of concurrent systems.
Proceedings Euromicro Workshop on Parallel and Distributed Processing
• 1995
This project aims to integrate a preferment communication unit that handles dynamic code distribution among all processors to gain execution time on massively parallel systems by reducing code loading.
• Computer Science
COORDINATION
• 2016
This paper reconciles two active object-based languages, ABS and ProActive, that respectively target the aforementioned goals, and introduces the translational semantics, and establishes the properties and the correctness of the translation.
• Computer Science
OOPSLA
• 2013
Disposal of dead actors in actor-model languages is as important as disposal of unreachable objects in object-oriented languages. In current practice, programmers are required to either manually
• Computer Science
MODULARITY
• 2015
This work formalizes Panini, presents its semantics and illustrates how its interference model, using behavioral contracts, enables Hoare-style modular reasoning about concurrent programs with interference.
• Computer Science
• 2007
Research issues in providing adaptivity support for prevalent paradigms are explored, important existing parallel programming languages are evaluated and virtualization techniques that bring the benefits of the ARTS to applications written using them are developed.
• Computer Science
• 1994
This thesis explores the adding of language and system support for general purpose parallel and distributed programming to the object-oriented language andSystem Raven, targeted for operation in shared-memory and distributed memory environments where the processors are general purpose and execute their own independent instruction streams.
The thesis proposes a parallel version of the Rete match algorithm which exploits parallelism at a very fine grain, and suggests that a suitable architecture to exploit the fine-grained parallelism is a shared-memory multiprocessor, with 32-64 high performance processors.

## References

SHOWING 1-10 OF 20 REFERENCES

• G. Agha
• Computer Science
MIT Press series in artificial intelligence
• 1985
A foundational model of concurrency is developed and issues in the design of parallel systems and why the actor model is suitable for exploiting large-scale parallelism are addressed.
This thesis extends and unifies the work of Carl Hewitt, Irene Greif, Henry Baker, and Giuseppe Attardi, who developed the mathematical content of the actor message-passing model, and may be proved for the semantics of an actor-based language.
• G. Agha
• Computer Science
Seminar on Concurrency
• 1984
A new formalism is developed to describe the behavior of actors and the evolution of systems of actors, called Sal, which has a simple syntax but nevertheless embodies the concepts involved.
This document describes issuess in Act2's design and the implementation of an interpreter for the language, providing high-level constructs suitable for implementing artificially-intelligent applications.
A programming language, Viron, is exhibited that capitalizes on five paradigm shifts in programming language design, namely Effect to Entity, Serial to Parallel, Partition Types to Predicate Types, Computable to Definable, and Syntactic Consistency to Semantic Consistsency.
A new class of computing systems uses the functional programming style both in its programming language and in its state transition rules; these systems have semantics loosely coupled to states—only one state transition occurs per major computation.
A model of net-connected processes is described that amounts to a reformulation of a model derived by Brock and Ackerman from the Kahn-McQueen model of processes as relations on streams of data, which leads directly to a straightforward definition of process composition.
• Computer Science
Seminar on Concurrency
• 1984
This work shows how receptionists can be used to regulate the use of shared resources by scheduling their access and providing protection against unauthorized or accidental access in the Actor Model of computation.
This paper suggests that input and output are basic primitives of programming and that parallel composition of communicating sequential processes is a fundamental program structuring method. When