- Sponsor:
- sigplan
AGERE! 2013 was the third iteration of AGERE! held alongside SPLASH. The workshop -- which focuses on concerns of modelling, design and programming of systems, where decentralized control is an underlying assumption -- has emerged as a venue that brings together approaches from a family of paradigms variously referred to as Actors, active objects, agents, etc. Actors and more broadly object-oriented concurrent programming -- which couple object-oriented programming with concurrency -- offer a clean and powerful model for computation, which is gaining in popularity with adoption in mainstream languages, frameworks and libraries. Agents and agent-oriented programming provide a further layer of abstraction on top of actors and objects, conceiving concurrent/distributed systems as organizations of autonomous task-oriented entities featuring proactive and reactive behaviors, and interacting in a shared environment.
The growing interest in libraries and frameworks supporting Actors or Actor-like mechanisms for use in mainstream platforms calls for tackling of both conceptual and practical hurdles that practitioners may face in using them. For example, how do we best integrate active and passive entities or entities based on different models of concurrency? More generally, it calls for tackling all those problems which become important as soon as these approaches start aiming to become the solution of choice for modelling, designing and programming large and complex software systems.
Accordingly, AGERE!'s general theme has evolved to address the question of how these models and abstractions can help improve the way we think about about problems, the way we design, implement, test and validate models and systems, and finally, inform the tools we develop to aid these processes.
AGERE! 2013 hosted two invited lectures, one by Yoshiki Ohshima from VPRI and another by Ole Lehrmann Madsen. Ohshima's talk -- titled "The future of personal computing system construction" -- reporting VPRI's work as part of the the STEP project -- discussed how the complexity of system construction can be tackled by creating meta-languages which allow us to build and experiment with new domain-specific languages. With these new languages, we can describe different parts of systems in a cleaner and more intention-revealing manner. From a conceptual point of view, objects remain the fundamental building blocks of the approach; however, decentralization of control and asynchronous interactions - alongside synchronous ones - appear to be a part of the foundation as well. Madsen's talk -- titled "SIMULA style concurrent objects" -- introduced sub-pattern restrictions as a mechanism used for defining safe concurrency abstractions in a new experimental version of Beta. Besides specific mechanisms, Beta -- being the successor of Simula -- has been designed to naturally support the modelling of concurrent activities, where Simula was originally designed to model and simulate activities in the real world.
Proceeding Downloads
Toward the future of personal computing system construction
The software for today's personal computing environments has become so complex that no single person can understand an entire system. Our group's early experiences with personal computing led us to understand that the essential model of personal ...
Cloud PARTE: elastic complex event processing based on mobile actors
Traffic monitoring or crowd management systems produce large amounts of data in the form of events that need to be processed to detect relevant incidents. Rule-based pattern recognition is a promising approach for these applications, however, increasing ...
Code management automation for Erlang remote actors
Distributed Erlang provides mechanisms for spawning actors remotely through its remote spawn BIF. For remote spawn to function properly, the node hosting the spawned actor must share the same codebase as that of the node launching the actor. This ...
Towards a compositional reflective architecture for actor-based systems
The goal of this work is to establish a simple and flexible construction method for reflective concurrent systems. In this paper, a novel method to construct a meta-level architecture for a group of actors is presented. The key idea is to apply parallel ...
Analysing timed Rebeca using McErlang
Although timed actor-based models attracted more attention in the recent years, there is not much done on analyzing and model checking of such systems. The actor based language, Timed Rebeca, was introduced to model distributed and asynchronous systems ...
Structured reasoning about actor systems
The actor model of distributed computing imposes important restrictions on concurrent computations in order to be valid. In particular, an actor language implementation must provide fairness, the property that if a system transition is infinitely often ...
Efficient and fully abstract routing of futures in object network overlays
In distributed object systems, it is desirable to enable migration of objects between locations, e.g., in order to support efficient resource allocation. Existing approaches build complex routing infrastructures to handle object-to-object communication, ...
Tanks: multiple reader, single writer actors
In the past, the Actor Model has mainly been explored in a distributed context. However, more and more application developers are also starting to use it to program shared-memory multicore machines because of the safety guarantees it provides. It avoids ...
Semantics-preserving sharing actors
Actors interact by asynchronous message passing. A key semantic property of actors is that they do not share state. This facilitates data-race freedom, fault isolation and location transparency. On the other hand, strict avoidance of sharing can lead to ...
Supporting many-to-many communication
In a variety of contexts -- from social media to wireless sensor networks -- we see increasingly complex patterns of communication, often characterized by having multiple senders for messages. This paper argues that existing communication mechanisms do ...
Native actors: a scalable software platform for distributed, heterogeneous environments
Writing concurrent software is challenging, especially with low-level synchronization primitives such as threads or locks in shared memory environments. The actor model replaces implicit communication by an explicit message passing in a 'hared-nothing' ...
Load balancing non-uniform parallel computations
Dynamic load balancing is critical in achieving high performance in parallel systems, especially for applications with unpredictable workloads. Traditional load balancing approaches -- such as work-sharing and work-stealing -- often assume that the ...
Improving the performance of actor model runtime environments on multicore and manycore platforms
The actor model is present in many systems that demand substantial computing resources which are often provided by multicore and multiprocessor platforms such as non-uniform memory access architectures (NUMA) and manycore processors. Yet, no mainstream ...
Towards benchmarking actor- and agent-based programming languages
Over the past few years there have been several advances in distributed systems, and more recently multi-core processors. Consequently, a natural need for concurrent and parallel programming languages arises. In this paper, we compare some aspects of ...
Concurrent object-oriented programming with agent-oriented abstractions: the ALOO approach
A long-standing problem in concurrent object-oriented programming is finding a sound and effective way to integrate active entities - being them actors, active objects, processes - with plain passive objects. Even if the problem is quite old, this is ...
A task framework on top of a concurrent OOP language rooted on agent-oriented abstractions
This paper describes a framework devised to ease the definition and management of complex tasks on top of ALOO, a novel Concurrent Object-Oriented Programming (COOP) language rooted on agent-oriented abstractions.
Back to the future: SIMULA style concurrent objects
In this talk, we will describe the approach to concurrency in SIMULA 67, the very first object-oriented language and the further development of this in the Beta language. Active objects in the form of coroutines are an integral part of the design of ...
Cited By
Index Terms
- Proceedings of the 2013 workshop on Programming based on actors, agents, and decentralized control
Recommendations
Special issue on programming based on actors, agents and decentralized control
The AGERE! workshop1 has been organized with the ACM SPLASH conference since 2011. The workshop has brought together researchers in programming systems, languages, and applications based on actors, active/concurrent objects, agents, and more broadly, ...
Acceptance Rates
Year | Submitted | Accepted | Rate |
---|---|---|---|
AGERE! '14 | 14 | 9 | 64% |
AGERE! 2013 | 21 | 10 | 48% |
Overall | 35 | 19 | 54% |