Actors: a model of concurrent computation in distributed systems
Actors: a model of concurrent computation in distributed systems
Object-oriented concurrent programming
Object-oriented concurrent programming
Traveler: the apiary observatory
European conference on object-oriented programming on ECOOP '87
Research directions in object-oriented programming
Research directions in object-oriented programming
Fine grain concurrent computations
Fine grain concurrent computations
Solving problems on concurrent processors. Vol. 1: General techniques and regular problems
Solving problems on concurrent processors. Vol. 1: General techniques and regular problems
Cantor: an actor programming system for scientific computing
OOPSLA/ECOOP '88 Proceedings of the 1988 ACM SIGPLAN workshop on Object-based concurrent programming
Inheritance and synchronization with enabled-sets
OOPSLA '89 Conference proceedings on Object-oriented programming systems, languages and applications
ABCL: an object-oriented concurrent system
ABCL: an object-oriented concurrent system
Issues in the design of a parallel object-oriented language
Formal Aspects of Computing
A VLSI Architecture for Concurrent Data Structures
A VLSI Architecture for Concurrent Data Structures
Universal Mechanisms for Concurrency
PARLE '89 Proceedings of the Parallel Architectures and Languages Europe, Volume I: Parallel Architectures
Supporting Multiparadigm Programming on Actor Architectures
PARLE '89 Proceedings of the Parallel Architectures and Languages Europe, Volume II: Parallel Languages
The object-oriented systems life cycle
Communications of the ACM
SIREDOJ: a legal assistance application about contracts in the building industry
ICAIL '91 Proceedings of the 3rd international conference on Artificial intelligence and law
COCS '91 Proceedings of the conference on Organizational computing systems
Introduction to the literature on object-oriented design, programming, and languages
ACM SIGPLAN OOPS Messenger
Concurrent organizational objects
OOPSLA/ECOOP '90 Proceedings of the workshop on Object-based concurrent programming
Object-oriented concurrent reflective languages can be implemented efficiently
OOPSLA '92 conference proceedings on Object-oriented programming systems, languages, and applications
A General Framework for Concurrent Simulation on Neural Network Models
IEEE Transactions on Software Engineering
Implementation of a portable nested data-parallel language
PPOPP '93 Proceedings of the fourth ACM SIGPLAN symposium on Principles and practice of parallel programming
Systematic concurrent object-oriented programming
Communications of the ACM
Introducing concurrency to a sequential language
Communications of the ACM
About conversations for concurrent OO languages
ACM SIGPLAN Notices
A modular approach to real-time synchronization
ACM SIGPLAN OOPS Messenger - Special issue: object-oriented real-time systems
Linguistic paradigms for programming complex distributed systems
ACM Computing Surveys (CSUR)
ICC++—a C++ dialect for high performance parallel computing
ACM SIGAPP Applied Computing Review
Class Library Support for Workflow Environments and Applications
IEEE Transactions on Computers
A multi-threaded object-oriented programming model
ACM SIGSOFT Software Engineering Notes
The concurrent object-oriented language braid
SAC '95 Proceedings of the 1995 ACM symposium on Applied computing
OFFERS — a tool for hierarchical implicit analysis of sequential object-oriented programs
SAC '96 Proceedings of the 1996 ACM symposium on Applied Computing
A Design Methodology for Data-Parallel Applications
IEEE Transactions on Software Engineering - Special issue on architecture-independent languages and software tools parallel processing
Programming languages and systems for prototyping concurrent applications
ACM Computing Surveys (CSUR)
Customizable middleware for modular distributed software
Communications of the ACM
A concurrency abstraction model for avoiding inheritance anomaly in object-oriented programs
Compiler optimizations for scalable parallel systems
Communications of the ACM - Adaptive middleware
Actors: a model for reasoning about open distributed systems
Formal methods for distributed processing
Designing a distributed computing environment for global-scale systems: challenges and issues
ACM SIGAPP Applied Computing Review
Towards reusable real-time objects
Annals of Software Engineering
Composable Semantic Models for Actor Theories
Higher-Order and Symbolic Computation
Abstraction and Modularity Mechanisms for Concurrent Computing
IEEE Parallel & Distributed Technology: Systems & Technology
The Extensible Services Switch in Carnot
IEEE Parallel & Distributed Technology: Systems & Technology
Actor theories in rewriting logic
Theoretical Computer Science - Rewriting logic and its applications
An Approach to Composing Parallel Programs
PaCT '01 Proceedings of the 6th International Conference on Parallel Computing Technologies
Flexible Agent Programming in Linear Logic
MICAI '02 Proceedings of the Second Mexican International Conference on Artificial Intelligence: Advances in Artificial Intelligence
Orgel: A Parallel Programming Language with Declarative Communication Streams
ISHPC '00 Proceedings of the Third International Symposium on High Performance Computing
Semantics of Agent Communication: An Introduction
Selected papers from the UKMAS Workshop on Foundations and Applications of Multi-Agent Systems
A foundation for actor computation
Journal of Functional Programming
Actor-oriented models for codesign: balancing re-use and performance
Formal methods and models for system design
Experience distributing objects in an SMMP OS
ACM Transactions on Computer Systems (TOCS)
Computing in pervasive cyberspace
Communications of the ACM - 50th anniversary issue: 1958 - 2008
Causality interfaces for actor networks
ACM Transactions on Embedded Computing Systems (TECS)
CPO semantics of timed interactive actor networks
Theoretical Computer Science
Cyber-Physical Systems and Events
Software-Intensive Systems and New Computing Paradigms
Classes and inheritance in actor-oriented design
ACM Transactions on Embedded Computing Systems (TECS)
A framework for managing the life-cycle of event-driven, embedded applications
Journal of Embedded Computing - Design and Optimization for High Performance Embedded Systems
Actor frameworks for the JVM platform: a comparative analysis
PPPJ '09 Proceedings of the 7th International Conference on Principles and Practice of Programming in Java
State management and concurrency in event processing
Proceedings of the Third ACM International Conference on Distributed Event-Based Systems
A Graphical User Interface for Maude-NPA
Electronic Notes in Theoretical Computer Science (ENTCS)
Actors and Logical Analysis of Interactive Systems
Electronic Notes in Theoretical Computer Science (ENTCS)
Agent-oriented programming: from prolog to guarded definite clauses
Agent-oriented programming: from prolog to guarded definite clauses
Proceedings of the ACM international conference companion on Object oriented programming systems languages and applications companion
Exploiting Inherent Task-Based Parallelism in Object-Oriented Programming
GRID '11 Proceedings of the 2011 IEEE/ACM 12th International Conference on Grid Computing
Proceedings of the compilation of the co-located workshops on DSM'11, TMC'11, AGERE!'11, AOOPES'11, NEAT'11, & VMIL'11
A framework for managing the solution life cycle of event-driven pervasive applications
EUC'06 Proceedings of the 2006 international conference on Embedded and Ubiquitous Computing
Concurrent semantics without the notions of state or state transitions
FORMATS'06 Proceedings of the 4th international conference on Formal Modeling and Analysis of Timed Systems
From actors to agent-oriented programming abstractions in simpAL
Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity
AGERE!: programming based on actors, agents, and decentralized control
Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity
Parallel gesture recognition with soft real-time guarantees
Proceedings of the 2nd edition on Programming systems, languages and applications based on actors, agents, and decentralized control abstractions
Proceedings of the 2nd edition on Programming systems, languages and applications based on actors, agents, and decentralized control abstractions
Proceedings of the Second International Workshop on Combined Object-Oriented Modelling and Programming Languages
Concurrent object-oriented programming with agents
Proceedings of the 2013 companion publication for conference on Systems, programming, & applications: software for humanity
Concurrent object-oriented programming with agent-oriented abstractions: the ALOO approach
Proceedings of the 2013 workshop on Programming based on actors, agents, and decentralized control
Hi-index | 48.28 |
Three significant trends have underscored the central role of concurrency in computing. First, there is increased use of interacting processes by individual users, for example, application programs running on X windows. Second, workstation networks have become a cost-effective mechanism for resource sharing and distributed problem solving. For example, loosely coupled problems, such as finding all the factors of large prime numbers, have been solved by utilizing ideal cycles on networks of hundreds of workstations. A loosely coupled problem is one which can be easily partitioned into many smaller subproblems so that interactions between the subproblems is quite limited. Finally, multiprocessor technology has advanced to the point of providing supercomputing power at a fraction of the traditional cost.At the same time, software engineering considerations such as the need for data abstraction to promote program modularity underlie the rapid acceptance of object-oriented programming methodology. By separating the specification of what is done (the abstraction) from how it is done (the implementation), the concept of objects provides modularity necessary for programming in the large. It turns out that concurrency is a natural consequence of the concept of objects. In fact Simula, the first object-oriented language, simulated a simple form of concurrency using coroutines on conventional architectures. Current development of concurrent object-oriented programming (COOP) is providing a solid software foundation for concurrent computing on multiprocessors, Future generation computing systems are likely to be based on the foundations being developed by this emerging software technology.The goal of this article is to discuss the foundations and methodology of COOP. Concurrency refers to the potentially parallel execution of parts of a computation. In a concurrent computation, the components of a program may be executed sequentially, or they may be executed in parallel. Concurrency provides us with the flexibility to interleave the execution of components of a program on a single processor, or to distribute it among several processors. Concurrency abstracts away some of the details in an execution, allowing us to concentrate on conceptual issues without having to be concerned with a particular order of execution which may result from the quirks of a given system.Objects can be defined as entities which encapsulate data and operations into a single computational unit. Object models differ in how the internal behavior of objects is specified. Further, models of concurrent computation based on objects must specify how the objects interact, and different design concerns have led to different models of communication between objects. Object-oriented programming builds on the concepts of objects by supporting patterns of reuse and classification, for example, through the use of inheritance which allows all instances of a particular class to share the same method.In the following section, we outline some common patterns of concurrent problem solving. These patterns can be easily expressed in terms of the rich variety of structures provided by COOP. In particular, we discuss the actor model as a framework for concurrent systems1 and some concepts which are useful in building actor systems. We will then describe some other models of objects and their relation to the actor model along with novel techniques for supporting reusability and modularity in concurrent object-oriented programming. The last section briefly outlines some major on-going projects in COOP.It is important to note that the actor languages give special emphasis to developing flexible program structures which simplify reasoning about programs. By reasoning we do not narrowly restrict ourselves to the problem of program verification—an important program of research whose direct practical utility has yet to be established. Rather our interest is in the ability to understand the properties of software because of clarity in the structure of the code. Such an understanding may be gained by reasoning either informally or formally about programs. The ease with which we can carry out such reasoning is aided by two factors: by modularity in code which is the result of the ability to separate design concerns, and by the ability to abstract program structures which occur repeatedly. In particular, because of their flexible structure, actor languages are particularly well-suited to rapid prototyping applications.