Flexibility and coordination in event-based, loosely coupled, distributed systems

The scale and diversity of interactions in current wide-area distributed programming environments, specially in Internet-based applications, point to the fact that there is no single solution for coordinating distributed applications. Instead, what is needed is the ability to easily build and combine different coordination abstractions. In this paper, we discuss the role of some language features, such as first-class function values, closures, and coroutines, in allowing different coordination mechanisms to be constructed out of a small set of communication primitives, and to be easily mixed and combined. Using the Lua programming language, we define a basic asynchronous primitive, which allows programming in a direct event-driven style with the syntax of function calls, and, based on this primitive, we build different well-known coordination abstractions for distributed computing.

[1]  Viktor Vafeiadis,et al.  Acute: high-level programming language design for distributed computation , 2005, ICFP '05.

[2]  José C. Cunha,et al.  Grid Computing: Software Environments and Tools , 2005 .

[3]  Martin Odersky,et al.  Event-Based Programming Without Inversion of Control , 2006, JMLC.

[4]  David R. Butenhof Programming with POSIX threads , 1993 .

[5]  Naranker Dulay,et al.  A constructive development environment for parallel and distributed programs , 1994, Proceedings of 2nd International Workshop on Configurable Distributed Systems.

[6]  Farhad Arbab,et al.  An overview of manifold and its implementation , 1993, Concurr. Pract. Exp..

[7]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[8]  Jonathan S. Shapiro,et al.  Concurrency among strangers: programming in E as plan coordination , 2005 .

[9]  Andrew S. Tanenbaum,et al.  A Critique of the Remote Procedure Call Paradigm , 1988 .

[10]  Steve Vinoski,et al.  RPC Under Fire , 2005, IEEE Internet Comput..

[11]  Marvin Theimer,et al.  Cooperative Task Management Without Manual Stack Management , 2002, USENIX Annual Technical Conference, General Track.

[12]  Roberto Ierusalimschy,et al.  LuaTS - A Reactive Event-Driven Tuple Space , 2003, J. Univers. Comput. Sci..

[13]  Guy L. Steele,et al.  Java(TM) Language Specification, The (3rd Edition) (Java (Addison-Wesley)) , 2005 .

[14]  Clemens A. Szyperski,et al.  Modular Programming Languages, 7th Joint Modular Languages Conference, JMLC 2006, Oxford, UK, September 13-15, 2006, Proceedings , 2006, JMLC.

[15]  Roberto Ierusalimschy,et al.  Programming in Lua , 2003 .

[16]  Raj Srinivasan,et al.  RPC: Remote Procedure Call Protocol Specification Version 2 , 1995, RFC.

[17]  George C. Necula,et al.  Capriccio: scalable threads for internet services , 2003, SOSP '03.

[18]  Joe Armstrong,et al.  Concurrent programming in ERLANG , 1993 .

[19]  Denis Caromel,et al.  Towards Seamless Computing and Metacomputing in Java , 1998, Concurr. Pract. Exp..

[20]  Nicholas Carriero,et al.  How to write parallel programs: a guide to the perplexed , 1989, CSUR.

[21]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[22]  Roberto Ierusalimschy,et al.  Lua—An Extensible Extension Language , 1996 .

[23]  Rachid Guerraoui,et al.  Concurrency and distribution in object-oriented programming , 1998, CSUR.

[24]  Ecma,et al.  Common Language Infrastructure (CLI) , 2001 .

[25]  environmet.,et al.  JXTA : A Network Programming Environment , 2022 .

[26]  Nicholas Carriero,et al.  Coordination languages and their significance , 1992, CACM.

[27]  Svend Frølund Coordinating distributed objects - an actor-based approach to synchronization , 1996 .

[28]  Carlos A. Varela,et al.  Programming dynamically reconfigurable open systems with SALSA , 2001, SIGP.

[29]  Roberto Ierusalimschy,et al.  ALua: flexibility for parallel programming , 2002, Comput. Lang. Syst. Struct..

[30]  Noemi de La Rocque Rodriguez,et al.  Integrating Remote Invocations with Asynchronism and Cooperative Multitasking , 2008, Parallel Process. Lett..

[31]  John W. Backus,et al.  Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs , 1978, CACM.

[32]  Robbert van Renesse,et al.  Reliable Distributed Computing with the Isis Toolkit , 1994 .

[33]  Larry Carter,et al.  Distrbution and Abstract Types in Emerald , 1987, IEEE Transactions on Software Engineering.

[34]  David E. Culler,et al.  SEDA: an architecture for well-conditioned, scalable internet services , 2001, SOSP.

[35]  Gregory R. Andrews,et al.  Foundations of Multithreaded, Parallel, and Distributed Programming , 1999 .

[36]  Steve Vinoski,et al.  Guest Editors' Introduction: Asynchronous Middleware and Services , 2006, IEEE Internet Computing.

[37]  Sun Microsystems,et al.  RPC: Remote Procedure Call Protocol specification , 1988, RFC.

[38]  David R. Karger,et al.  Chord: A scalable peer-to-peer lookup service for internet applications , 2001, SIGCOMM '01.

[39]  Denis Caromel,et al.  Programming, Composing, Deploying for the Grid , 2006, Grid Computing: Software Environments and Tools.

[40]  Henri E. Bal,et al.  Orca: A Language For Parallel Programming of Distributed Systems , 1992, IEEE Trans. Software Eng..

[41]  Jean-pierre Briot Actalk: A Framework for Object-Oriented Concurrent Programming - Design and Experience , 1999 .

[42]  Douglas C. Schmidt,et al.  Half-sync/half-async: an architectural pattern for efficient and well-structured concurrent I/O , 1996 .

[43]  Gul A. Agha,et al.  Abstraction and modularity mechanisms for concurrent computing , 1993, IEEE Parallel & Distributed Technology: Systems & Applications.

[44]  Sun Microsystems,et al.  RPC: Remote Procedure Call Protocol specification: Version 2 , 1988, RFC.

[45]  Frederic P. Miller,et al.  Lua (programming language) , 2009 .

[46]  Distributed Computation,et al.  Object-oriented parallel and distributed programming , 2000 .

[47]  Jon Sigel,et al.  CORBA Fundamentals and Programming , 1996 .

[48]  Martin Odersky,et al.  Scala Actors: Unifying thread-based and event-based programming , 2009, Theor. Comput. Sci..

[49]  Gul Agha,et al.  Programming dynamically reconfigurable open systems with SALSA : Intriguing Technology from OOPSLA by John Vlissides and Doug Lea , 2001 .

[50]  Michel Riveill Synchronizing shared objects , 1995, Distributed Syst. Eng..

[51]  Farhad Arbab,et al.  Coordination Models and Languages , 1998, Adv. Comput..

[52]  Patrick Th. Eugster,et al.  On objects and events , 2001, OOPSLA '01.

[53]  Henry Lieberman,et al.  Concurrent object-oriented programming in Act 1 , 1987 .

[54]  Gregory R. Andrews,et al.  Concepts and Notations for Concurrent Programming , 1983, CSUR.

[55]  Akkihebbal L. Ananda,et al.  A survey of asynchronous remote procedure calls , 1992, OPSR.

[56]  Rich Hickey,et al.  The Clojure programming language , 2008, DLS '08.

[57]  Liuba Shrira,et al.  Promises: linguistic support for efficient asynchronous procedure calls in distributed systems , 1988, PLDI '88.

[58]  John K. Ousterhout,et al.  Why Threads Are A Bad Idea (for most purposes) , 2003 .