B C D H K L M P R S Z

	Balzer, Stephanie	AGERE! '15: "Objects as Session-Typed Processes ..." Objects as Session-Typed Processes Stephanie Balzer and Frank Pfenning (Carnegie Mellon University, USA) A key idea in object-oriented programming is that objects encapsulate state and interact with each other by message exchange. This perspective suggests a model of computation that is inherently concurrent (to facilitate simultaneous message exchange) and that accounts for the effect of message exchange on an object's state (to express valid sequences of state transitions). In this paper we show that such a model of computation arises naturally from session-based communication. We introduce an object-oriented programming language that has processes as its only objects and employs linear session types to express the protocols of message exchange and to reason about concurrency and state. Based on various examples we show that our language supports the typical patterns of object-oriented programming (e.g., encapsulation, dynamic dispatch, and subtyping) while guaranteeing session fidelity in a concurrent setting. In addition, we show that our language facilitates new forms of expression (e.g., type-directed reuse, internal choice), which are not available in current object-oriented languages. We have implemented our language in a prototype compiler. @InProceedings{AGERE!15p13, author = {Stephanie Balzer and Frank Pfenning}, title = {Objects as Session-Typed Processes}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {13--24}, doi = {}, year = {2015}, }
	Blessing, Sebastian	AGERE! '15: "Deny Capabilities for Safe, ..." Deny Capabilities for Safe, Fast Actors Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, and Andy McNeil (Imperial College London, UK) Abstract Combining the actor-model with shared memory for performance is efficient but can introduce data-races. Existing approaches to static data-race freedom are based on uniqueness and immutability, but lack flexibility and high performance implementations. Our approach, based on deny properties, allows reading, writing and traversing unique references, introduces a new form of write uniqueness, and guarantees atomic behaviours. @InProceedings{AGERE!15p1, author = {Sylvan Clebsch and Sophia Drossopoulou and Sebastian Blessing and Andy McNeil}, title = {Deny Capabilities for Safe, Fast Actors}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {1--12}, doi = {}, year = {2015}, } Video Info
	Charousset, Dominik	AGERE! '15: "Manyfold Actors: Extending ..." Manyfold Actors: Extending the C++ Actor Framework to Heterogeneous Many-Core Machines using OpenCL Raphael Hiesgen, Dominik Charousset, and Thomas C. Schmidt (University of Applied Sciences Hamburg, Germany) The processing power of modern many core hardware such as graphics processing units (GPUs) or coprocessors is increasingly available for general-purpose computation. The seamless way of actor systems to addresses concurrent and distributed programming makes it an attractive approach to integrate these novel architectures. In this work, we introduce OpenCL-enabled actors to the C++ Actor Framework (CAF). This offers a high level interface for accessing any OpenCL device without leaving the actor paradigm. The new type of actor is integrated into the runtime environment of CAF and gives rise to transparent message passing in distributed systems on heterogeneous hardware. New actors are instantiated by the function spawn_cl, while the runtime environment handles the discovery and setup of OpenCL devices in the background. Our evaluations on a commodity GPU, an Nvidia TESLA, and an Intel PHI reveal the expected linear scaling behavior when offloading larger work items. For sub-second duties, the efficiency of offloading was found to largely differ between devices. Moreover, our findings indicate a negligible overhead over programming the native OpenCL API. @InProceedings{AGERE!15p45, author = {Raphael Hiesgen and Dominik Charousset and Thomas C. Schmidt}, title = {Manyfold Actors: Extending the C++ Actor Framework to Heterogeneous Many-Core Machines using OpenCL}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {45--56}, doi = {}, year = {2015}, }
	Clebsch, Sylvan	AGERE! '15: "Deny Capabilities for Safe, ..." Deny Capabilities for Safe, Fast Actors Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, and Andy McNeil (Imperial College London, UK) Abstract Combining the actor-model with shared memory for performance is efficient but can introduce data-races. Existing approaches to static data-race freedom are based on uniqueness and immutability, but lack flexibility and high performance implementations. Our approach, based on deny properties, allows reading, writing and traversing unique references, introduces a new form of write uniqueness, and guarantees atomic behaviours. @InProceedings{AGERE!15p1, author = {Sylvan Clebsch and Sophia Drossopoulou and Sebastian Blessing and Andy McNeil}, title = {Deny Capabilities for Safe, Fast Actors}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {1--12}, doi = {}, year = {2015}, } Video Info
	Collier, Rem W.	AGERE! '15: "Exploring AOP from an OOP ..." Exploring AOP from an OOP Perspective Rem W. Collier, Seán Russell, and David Lillis (University College Dublin, Ireland) Agent-Oriented Programming (AOP) researchers have successfully developed a range of agent programming languages that bridge the gap between theory and practice. Unfortunately, despite the in-community success of these languages, they have proven less compelling to the wider software engineering community. One of the main problems facing AOP language developers is the need to bridge the cognitive gap that exists between the concepts underpinning mainstream languages and those underpinning AOP. In this paper, we attempt to build such a bridge through a conceptual mapping between Object-Oriented Programming (OOP) and the AgentSpeak(L) family of AOP languages. This mapping explores how OOP concepts and the concurrent programming concept of threads relate to AgentSpeak(L) concepts. We then use our analysis of this mapping to drive the design of a new programming language entitled ASTRA. @InProceedings{AGERE!15p25, author = {Rem W. Collier and Seán Russell and David Lillis}, title = {Exploring AOP from an OOP Perspective}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {25--36}, doi = {}, year = {2015}, }
	Drossopoulou, Sophia	AGERE! '15: "Deny Capabilities for Safe, ..." Deny Capabilities for Safe, Fast Actors Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, and Andy McNeil (Imperial College London, UK) Abstract Combining the actor-model with shared memory for performance is efficient but can introduce data-races. Existing approaches to static data-race freedom are based on uniqueness and immutability, but lack flexibility and high performance implementations. Our approach, based on deny properties, allows reading, writing and traversing unique references, introduces a new form of write uniqueness, and guarantees atomic behaviours. @InProceedings{AGERE!15p1, author = {Sylvan Clebsch and Sophia Drossopoulou and Sebastian Blessing and Andy McNeil}, title = {Deny Capabilities for Safe, Fast Actors}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {1--12}, doi = {}, year = {2015}, } Video Info
	Haller, Philipp	AGERE! '15: "Akka.js: Towards a Portable ..." Akka.js: Towards a Portable Actor Runtime Environment Gianluca Stivan, Andrea Peruffo, and Philipp Haller (UniCredit, Italy; KTH, Sweden) Multiple mature implementations of the actor model of concurrency exist. Besides several ones available for the Java Virtual Machine, there are others, for example, written in SmallTalk or in C++, targeting native platforms or other virtual machines. Recently, runtime environments for platforms such as GPUs have also appeared. However, so far, no full-featured, distributed actor runtime environment has allowed actor programs to run, unchanged, on both Java and JavaScript virtual machines. This paper describes our ongoing effort in providing a portable implementation of the widely-used Akka actor framework. @InProceedings{AGERE!15p57, author = {Gianluca Stivan and Andrea Peruffo and Philipp Haller}, title = {Akka.js: Towards a Portable Actor Runtime Environment}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {57--64}, doi = {}, year = {2015}, }
	Hiesgen, Raphael	AGERE! '15: "Manyfold Actors: Extending ..." Manyfold Actors: Extending the C++ Actor Framework to Heterogeneous Many-Core Machines using OpenCL Raphael Hiesgen, Dominik Charousset, and Thomas C. Schmidt (University of Applied Sciences Hamburg, Germany) The processing power of modern many core hardware such as graphics processing units (GPUs) or coprocessors is increasingly available for general-purpose computation. The seamless way of actor systems to addresses concurrent and distributed programming makes it an attractive approach to integrate these novel architectures. In this work, we introduce OpenCL-enabled actors to the C++ Actor Framework (CAF). This offers a high level interface for accessing any OpenCL device without leaving the actor paradigm. The new type of actor is integrated into the runtime environment of CAF and gives rise to transparent message passing in distributed systems on heterogeneous hardware. New actors are instantiated by the function spawn_cl, while the runtime environment handles the discovery and setup of OpenCL devices in the background. Our evaluations on a commodity GPU, an Nvidia TESLA, and an Intel PHI reveal the expected linear scaling behavior when offloading larger work items. For sub-second duties, the efficiency of offloading was found to largely differ between devices. Moreover, our findings indicate a negligible overhead over programming the native OpenCL API. @InProceedings{AGERE!15p45, author = {Raphael Hiesgen and Dominik Charousset and Thomas C. Schmidt}, title = {Manyfold Actors: Extending the C++ Actor Framework to Heterogeneous Many-Core Machines using OpenCL}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {45--56}, doi = {}, year = {2015}, }
	Khamespanah, Ehsan	AGERE! '15: "Jacco: More Efficient Model ..." Jacco: More Efficient Model Checking Toolset for Java Actor Programs Arvin Zakeriyan, Ehsan Khamespanah, Marjan Sirjani, and Ramtin Khosravi (University of Tehran, Iran; Reykjavik University, Iceland) Actors provide concurrent, distributed, and event-driven autonomous objects which communicate asynchronously. Actor model benefits from higher level of scalability and actor programs are less error-prone in comparison to programs developed in other concurrent models. However, it does not prevent the racing and concurrency errors. So, to guarantee the correctness of mission critical actor programs, verification techniques like model checking are needed. Previously, Basset has been developed based on Java PathFinder, for model checking of Java actor programs. The message scheduling approach of Basset can cause false negative results as well as and early state space exploration. In addition, using Java PathFinder as the back-end model checker imposes the execution time inefficiencies. To resolve these issues, we developed Jacco as the direct model checking toolset for Java actor programs. We provided a new message scheduling approach and implemented it in Java. To illustrate how efficiently Jacco works, Basset and Jacco model checking results are compared for a number of case studies. We also used Jacco for the model checking of a real-world program in robotics systems. @InProceedings{AGERE!15p37, author = {Arvin Zakeriyan and Ehsan Khamespanah and Marjan Sirjani and Ramtin Khosravi}, title = {Jacco: More Efficient Model Checking Toolset for Java Actor Programs}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {37--44}, doi = {}, year = {2015}, }
	Khosravi, Ramtin	AGERE! '15: "Jacco: More Efficient Model ..." Jacco: More Efficient Model Checking Toolset for Java Actor Programs Arvin Zakeriyan, Ehsan Khamespanah, Marjan Sirjani, and Ramtin Khosravi (University of Tehran, Iran; Reykjavik University, Iceland) Actors provide concurrent, distributed, and event-driven autonomous objects which communicate asynchronously. Actor model benefits from higher level of scalability and actor programs are less error-prone in comparison to programs developed in other concurrent models. However, it does not prevent the racing and concurrency errors. So, to guarantee the correctness of mission critical actor programs, verification techniques like model checking are needed. Previously, Basset has been developed based on Java PathFinder, for model checking of Java actor programs. The message scheduling approach of Basset can cause false negative results as well as and early state space exploration. In addition, using Java PathFinder as the back-end model checker imposes the execution time inefficiencies. To resolve these issues, we developed Jacco as the direct model checking toolset for Java actor programs. We provided a new message scheduling approach and implemented it in Java. To illustrate how efficiently Jacco works, Basset and Jacco model checking results are compared for a number of case studies. We also used Jacco for the model checking of a real-world program in robotics systems. @InProceedings{AGERE!15p37, author = {Arvin Zakeriyan and Ehsan Khamespanah and Marjan Sirjani and Ramtin Khosravi}, title = {Jacco: More Efficient Model Checking Toolset for Java Actor Programs}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {37--44}, doi = {}, year = {2015}, }
	Lillis, David	AGERE! '15: "Exploring AOP from an OOP ..." Exploring AOP from an OOP Perspective Rem W. Collier, Seán Russell, and David Lillis (University College Dublin, Ireland) Agent-Oriented Programming (AOP) researchers have successfully developed a range of agent programming languages that bridge the gap between theory and practice. Unfortunately, despite the in-community success of these languages, they have proven less compelling to the wider software engineering community. One of the main problems facing AOP language developers is the need to bridge the cognitive gap that exists between the concepts underpinning mainstream languages and those underpinning AOP. In this paper, we attempt to build such a bridge through a conceptual mapping between Object-Oriented Programming (OOP) and the AgentSpeak(L) family of AOP languages. This mapping explores how OOP concepts and the concurrent programming concept of threads relate to AgentSpeak(L) concepts. We then use our analysis of this mapping to drive the design of a new programming language entitled ASTRA. @InProceedings{AGERE!15p25, author = {Rem W. Collier and Seán Russell and David Lillis}, title = {Exploring AOP from an OOP Perspective}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {25--36}, doi = {}, year = {2015}, }
	McNeil, Andy	AGERE! '15: "Deny Capabilities for Safe, ..." Deny Capabilities for Safe, Fast Actors Sylvan Clebsch, Sophia Drossopoulou, Sebastian Blessing, and Andy McNeil (Imperial College London, UK) Abstract Combining the actor-model with shared memory for performance is efficient but can introduce data-races. Existing approaches to static data-race freedom are based on uniqueness and immutability, but lack flexibility and high performance implementations. Our approach, based on deny properties, allows reading, writing and traversing unique references, introduces a new form of write uniqueness, and guarantees atomic behaviours. @InProceedings{AGERE!15p1, author = {Sylvan Clebsch and Sophia Drossopoulou and Sebastian Blessing and Andy McNeil}, title = {Deny Capabilities for Safe, Fast Actors}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {1--12}, doi = {}, year = {2015}, } Video Info
	Peruffo, Andrea	AGERE! '15: "Akka.js: Towards a Portable ..." Akka.js: Towards a Portable Actor Runtime Environment Gianluca Stivan, Andrea Peruffo, and Philipp Haller (UniCredit, Italy; KTH, Sweden) Multiple mature implementations of the actor model of concurrency exist. Besides several ones available for the Java Virtual Machine, there are others, for example, written in SmallTalk or in C++, targeting native platforms or other virtual machines. Recently, runtime environments for platforms such as GPUs have also appeared. However, so far, no full-featured, distributed actor runtime environment has allowed actor programs to run, unchanged, on both Java and JavaScript virtual machines. This paper describes our ongoing effort in providing a portable implementation of the widely-used Akka actor framework. @InProceedings{AGERE!15p57, author = {Gianluca Stivan and Andrea Peruffo and Philipp Haller}, title = {Akka.js: Towards a Portable Actor Runtime Environment}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {57--64}, doi = {}, year = {2015}, }
	Pfenning, Frank	AGERE! '15: "Objects as Session-Typed Processes ..." Objects as Session-Typed Processes Stephanie Balzer and Frank Pfenning (Carnegie Mellon University, USA) A key idea in object-oriented programming is that objects encapsulate state and interact with each other by message exchange. This perspective suggests a model of computation that is inherently concurrent (to facilitate simultaneous message exchange) and that accounts for the effect of message exchange on an object's state (to express valid sequences of state transitions). In this paper we show that such a model of computation arises naturally from session-based communication. We introduce an object-oriented programming language that has processes as its only objects and employs linear session types to express the protocols of message exchange and to reason about concurrency and state. Based on various examples we show that our language supports the typical patterns of object-oriented programming (e.g., encapsulation, dynamic dispatch, and subtyping) while guaranteeing session fidelity in a concurrent setting. In addition, we show that our language facilitates new forms of expression (e.g., type-directed reuse, internal choice), which are not available in current object-oriented languages. We have implemented our language in a prototype compiler. @InProceedings{AGERE!15p13, author = {Stephanie Balzer and Frank Pfenning}, title = {Objects as Session-Typed Processes}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {13--24}, doi = {}, year = {2015}, }
	Russell, Seán	AGERE! '15: "Exploring AOP from an OOP ..." Exploring AOP from an OOP Perspective Rem W. Collier, Seán Russell, and David Lillis (University College Dublin, Ireland) Agent-Oriented Programming (AOP) researchers have successfully developed a range of agent programming languages that bridge the gap between theory and practice. Unfortunately, despite the in-community success of these languages, they have proven less compelling to the wider software engineering community. One of the main problems facing AOP language developers is the need to bridge the cognitive gap that exists between the concepts underpinning mainstream languages and those underpinning AOP. In this paper, we attempt to build such a bridge through a conceptual mapping between Object-Oriented Programming (OOP) and the AgentSpeak(L) family of AOP languages. This mapping explores how OOP concepts and the concurrent programming concept of threads relate to AgentSpeak(L) concepts. We then use our analysis of this mapping to drive the design of a new programming language entitled ASTRA. @InProceedings{AGERE!15p25, author = {Rem W. Collier and Seán Russell and David Lillis}, title = {Exploring AOP from an OOP Perspective}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {25--36}, doi = {}, year = {2015}, }
	Schmidt, Thomas C.	AGERE! '15: "Manyfold Actors: Extending ..." Manyfold Actors: Extending the C++ Actor Framework to Heterogeneous Many-Core Machines using OpenCL Raphael Hiesgen, Dominik Charousset, and Thomas C. Schmidt (University of Applied Sciences Hamburg, Germany) The processing power of modern many core hardware such as graphics processing units (GPUs) or coprocessors is increasingly available for general-purpose computation. The seamless way of actor systems to addresses concurrent and distributed programming makes it an attractive approach to integrate these novel architectures. In this work, we introduce OpenCL-enabled actors to the C++ Actor Framework (CAF). This offers a high level interface for accessing any OpenCL device without leaving the actor paradigm. The new type of actor is integrated into the runtime environment of CAF and gives rise to transparent message passing in distributed systems on heterogeneous hardware. New actors are instantiated by the function spawn_cl, while the runtime environment handles the discovery and setup of OpenCL devices in the background. Our evaluations on a commodity GPU, an Nvidia TESLA, and an Intel PHI reveal the expected linear scaling behavior when offloading larger work items. For sub-second duties, the efficiency of offloading was found to largely differ between devices. Moreover, our findings indicate a negligible overhead over programming the native OpenCL API. @InProceedings{AGERE!15p45, author = {Raphael Hiesgen and Dominik Charousset and Thomas C. Schmidt}, title = {Manyfold Actors: Extending the C++ Actor Framework to Heterogeneous Many-Core Machines using OpenCL}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {45--56}, doi = {}, year = {2015}, }
	Sirjani, Marjan	AGERE! '15: "Jacco: More Efficient Model ..." Jacco: More Efficient Model Checking Toolset for Java Actor Programs Arvin Zakeriyan, Ehsan Khamespanah, Marjan Sirjani, and Ramtin Khosravi (University of Tehran, Iran; Reykjavik University, Iceland) Actors provide concurrent, distributed, and event-driven autonomous objects which communicate asynchronously. Actor model benefits from higher level of scalability and actor programs are less error-prone in comparison to programs developed in other concurrent models. However, it does not prevent the racing and concurrency errors. So, to guarantee the correctness of mission critical actor programs, verification techniques like model checking are needed. Previously, Basset has been developed based on Java PathFinder, for model checking of Java actor programs. The message scheduling approach of Basset can cause false negative results as well as and early state space exploration. In addition, using Java PathFinder as the back-end model checker imposes the execution time inefficiencies. To resolve these issues, we developed Jacco as the direct model checking toolset for Java actor programs. We provided a new message scheduling approach and implemented it in Java. To illustrate how efficiently Jacco works, Basset and Jacco model checking results are compared for a number of case studies. We also used Jacco for the model checking of a real-world program in robotics systems. @InProceedings{AGERE!15p37, author = {Arvin Zakeriyan and Ehsan Khamespanah and Marjan Sirjani and Ramtin Khosravi}, title = {Jacco: More Efficient Model Checking Toolset for Java Actor Programs}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {37--44}, doi = {}, year = {2015}, }
	Stivan, Gianluca	AGERE! '15: "Akka.js: Towards a Portable ..." Akka.js: Towards a Portable Actor Runtime Environment Gianluca Stivan, Andrea Peruffo, and Philipp Haller (UniCredit, Italy; KTH, Sweden) Multiple mature implementations of the actor model of concurrency exist. Besides several ones available for the Java Virtual Machine, there are others, for example, written in SmallTalk or in C++, targeting native platforms or other virtual machines. Recently, runtime environments for platforms such as GPUs have also appeared. However, so far, no full-featured, distributed actor runtime environment has allowed actor programs to run, unchanged, on both Java and JavaScript virtual machines. This paper describes our ongoing effort in providing a portable implementation of the widely-used Akka actor framework. @InProceedings{AGERE!15p57, author = {Gianluca Stivan and Andrea Peruffo and Philipp Haller}, title = {Akka.js: Towards a Portable Actor Runtime Environment}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {57--64}, doi = {}, year = {2015}, }
	Zakeriyan, Arvin	AGERE! '15: "Jacco: More Efficient Model ..." Jacco: More Efficient Model Checking Toolset for Java Actor Programs Arvin Zakeriyan, Ehsan Khamespanah, Marjan Sirjani, and Ramtin Khosravi (University of Tehran, Iran; Reykjavik University, Iceland) Actors provide concurrent, distributed, and event-driven autonomous objects which communicate asynchronously. Actor model benefits from higher level of scalability and actor programs are less error-prone in comparison to programs developed in other concurrent models. However, it does not prevent the racing and concurrency errors. So, to guarantee the correctness of mission critical actor programs, verification techniques like model checking are needed. Previously, Basset has been developed based on Java PathFinder, for model checking of Java actor programs. The message scheduling approach of Basset can cause false negative results as well as and early state space exploration. In addition, using Java PathFinder as the back-end model checker imposes the execution time inefficiencies. To resolve these issues, we developed Jacco as the direct model checking toolset for Java actor programs. We provided a new message scheduling approach and implemented it in Java. To illustrate how efficiently Jacco works, Basset and Jacco model checking results are compared for a number of case studies. We also used Jacco for the model checking of a real-world program in robotics systems. @InProceedings{AGERE!15p37, author = {Arvin Zakeriyan and Ehsan Khamespanah and Marjan Sirjani and Ramtin Khosravi}, title = {Jacco: More Efficient Model Checking Toolset for Java Actor Programs}, booktitle = {Proc.\ AGERE!}, publisher = {ACM}, pages = {37--44}, doi = {}, year = {2015}, }

19 authors

proc time: 1.22