A Classification of Various Approaches for Object-Based Parallel and Distributed Prgramming

This paper aims at classifying and discussing the various ways along which the object paradigm is used in concurrent and distributed contexts. We distinguish the applicative approach, the integrative approach, and the reflective approach. The applicative approach applies object-oriented concepts, as they are, to structure concurrent and distributed systems through libraries. The integrative approach consists in merging concepts such as: object and activity, message passing and transaction, etc. The reflective approach integrates protocol libraries intimately within an object-based programming language. We discuss and illustrate each of these approaches and we point out their complementary levels and goals.

[1]  Denis Caromel,et al.  Toward a method of object-oriented concurrent programming , 1993, CACM.

[2]  Jan van den Bos,et al.  A concurrent object-oriented language with protocols delegation and constraints , 2005 .

[3]  Jeannette M. Wing.  Decomposing and Recomposing Transactional Concepts , 1993, ECOOP Workshop.

[4]  Doug Lea,et al.  Concurrent Programming In Java , 1996 .

[5]  Gul A. Agha,et al.  Concurrent object-oriented programming , 1993, CACM.

[6]  Akinori Yonezawa,et al.  Abstracting Object Interactions Using Composition Filters , 1993, ECOOP Workshop.

[7]  Satoshi Matsuoka,et al.  Object Technologies for Advanced Software , 1996, Lecture Notes in Computer Science.

[8]  Rachid Guerraoui,et al.  Software-Based Replication for Fault Tolerance , 1997, Computer.

[9]  Yasuhiko Yokote,et al.  The Apertos reflective operating system: the concept and its implementation , 1992, OOPSLA.

[10]  Andrew P. Black,et al.  Encapsulating Plurality , 1993, ECOOP.

[11]  Rachid Guerraoui,et al.  Building Reliable Client-Server Software Using Actively Replicated Objects , 1995 .

[12]  Wooyoung Kim.  A Linguistic Framework for Dynamic Composition of Dependability Protocols , 1993 .

[13]  Michel Riveill,et al.  The Guide Language , 1994, Comput. J..

[14]  Gul Agha,et al.  Research directions in concurrent object-oriented programming , 1993 .

[15]  Francisco Moura,et al.  Integration of Concurrency Control in a Language with Subtyping and Subclassing , 1995, COOTS.

[16]  Andrew P. Black,et al.  Understanding transactions in the operating system context , 1991, OPSR.

[17]  John L. Bruno,et al.  Introducing concurrency to a sequential language , 1993, CACM.

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

[19]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[20]  Rachid Guerraoui,et al.  Protocol Classes for Designing Reliable Distributed Environments , 1996, ECOOP.

[21]  R. Guerraoui,et al.  On the use of Smalltalk for Concurrent and Distributed Programming , 1996 .

[22]  William E. Weihl,et al.  Local atomicity properties: modular concurrency control for abstract data types , 1989, TOPL.

[23]  Peter Wegner.  Dimensions of object-based language design , 1987, OOPSLA 1987.

[24]  Calton Pu,et al.  A Practical and Modular Implementation of Extended Transaction Models , 1995, VLDB.

[25]  Oscar Nierstrasz,et al.  Object-Based Distributed Programming , 1993, Lecture Notes in Computer Science.

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

[27]  Julian Padget,et al.  An Overview of EULISP , 1993, LISP and Symbolic Computation.

[28]  Jean-Marc Geib,et al.  Object-Based Parallel and Distributed Computation , 1996, Lecture Notes in Computer Science.

[29]  Jean Bézivin.  Some experiments in object-oriented simulation , 1987, OOPSLA 1987.

[30]  Ciaran Mchale,et al.  Synchronisation in Concurrent, Object-oriented Languages: Expressive Power, Genericity and Inheritan , 1994 .

[31]  O. J. Dahl,et al.  Simula Begin , 1979 .

[32]  Thomas J. Mowbray,et al.  The essential CORBA - systems integration using distributed objects , 1995 .

[33]  Rachid Guerraoui,et al.  Implementation of the GARF replicated objects platform , 1995, Distributed Syst. Eng..

[34]  J. Bézivin,et al.  ECOOP’ 87 European Conference on Object-Oriented Programming , 1987, Lecture Notes in Computer Science.

[35]  Rachid Guerraoui,et al.  Distributed Programming in GARF , 1993, ECOOP Workshop.

[36]  Barbara Liskov,et al.  Guardians and Actions: Linguistic Support for Robust, Distributed Programs , 1983, TOPL.

[37]  Jean-Pierre Briot.  An Experiment in Classification and Specialization of Synchronization Schemes , 1996, ISOTAS.

[38]  Pattie Maes.  Concepts and experiments in computational reflection , 1987, OOPSLA 1987.

[39]  Bertrand Meyer,et al.  Systematic concurrent object-oriented programming , 1993, CACM.

[40]  André Schiper,et al.  Theory and Practice in Distributed Systems , 1995, Lecture Notes in Computer Science.

[41]  Yasuhiko Yokote,et al.  The Apertos reflective operating system: the concept and its implementation , 1992, OOPSLA '92.

[42]  Stein Gjessing,et al.  ECOOP ’88 European Conference on Object-Oriented Programming , 1988, Lecture Notes in Computer Science.

[43]  Rachid Guerraoui,et al.  Strategic directions in object-oriented programming , 1996, CSUR.

[44]  John R. Nicol,et al.  Object orientation in heterogeneous distributed computing systems , 1993, Computer.

[45]  Laurent Thomas,et al.  Extensibility and Reuse of Object-Oriented Synchronization Components , 1992, PARLE.

[46]  Jean-Pierre Briot,et al.  Actalk: A Testbed for Classifying and Designing Actor Languages in the Smalltalk-80 Environment , 1989, ECOOP.

[47]  Satoshi Matsuoka,et al.  Compiling away the meta-level in object-oriented concurrent reflective languages using partial evaluation , 1995, OOPSLA.

[48]  허진호.  [參觀記] European Conference on Object Oriented Programming 참관기 , 1988 .

[49]  Rachid Guerraoui.  Modular Atomic Objects , 1995, Theory Pract. Object Syst..

[50]  Peter Wegner,et al.  Dimensions of object-based language design , 1987, OOPSLA '87.

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

[52]  Rachid Guerraoui,et al.  Nesting Actions through Asynchronous Message Passing: the ACS Protocol , 1992, ECOOP.

[53]  Roy H. Campbell,et al.  Designing and implementing Choices: an object-oriented system in C++ , 1993, CACM.

[54]  O. Lehrmann Madsen,et al.  ECOOP ’92 European Conference on Object-Oriented Programming , 1992, Lecture Notes in Computer Science.

[55]  Jean-Marc Jézéquel,et al.  Transparent Parallelisation Through Reuse: Between a Compiler and a Library Approach , 1993, ECOOP.

[56]  Santosh K. Shrivastava,et al.  Implementing Concurrency Control in Reliable Distributed Object Oriented Systems , 1988 .

[57]  Rodger Lea,et al.  COOL: system support for distributed programming , 1993, CACM.

[58]  Jeff McAffer.  Meta-level Programming with CodA , 1995, ECOOP.

[59]  Pierre America,et al.  Pool-T: a parallel object-oriented language , 1987 .

[60]  Santosh K. Shrivastava,et al.  Implementing Concurrency Control in Reliable Object-Oriented Systems , 1988, ECOOP.

[61]  Satoshi Matsuoka,et al.  Analysis of inheritance anomaly in object-oriented concurrent programming languages , 1993 .

[62]  Jean Bézivin,et al.  Some experiments in object-oriented simulation , 1987, OOPSLA '87.

[63]  Barbara Liskov,et al.  Guardians and actions: linguistic support for robust, distributed programs , 1982, POPL '82.

[64]  Loic Lescaudron,et al.  Prototypage d'environnements de programmation pour les langages a objets concurrents : une realisation en smalltalk-80 pour actalk , 1992 .

[65]  Ole Lehrmann Madsen,et al.  Object-Oriented Distributed Programming in BETA , 1993, ECOOP Workshop.

[66]  Yutaka Ishikawa,et al.  Object Location Control Using Meta-level Programming , 1994, ECOOP.

[67]  Cristina V. Lopes,et al.  Abstracting Process-to-Function Relations in Concurrency Object-Oriented Applications , 1994, ECOOP.

[68]  Rachid Guerraoui,et al.  Using the Strategy Design Pattern to Compose Reliable Distributed Protocols , 1997, COOTS.

[69]  Jee Mcaaer.  Meta-level Programming with Coda , 1995 .

[70]  Oscar M. Nierstrasz,et al.  ECOOP’ 93 — Object-Oriented Programming , 2000, Lecture Notes in Computer Science.

[71]  Rachid Guerraoui,et al.  Lessons from implementing active objects on a parallel machine , 1992 .

[72]  Klaus-Peter Löhr,et al.  Object-Oriented Concurrent Programming , 1992, TOOLS.

[73]  Akinori Yonezawa,et al.  Inheritance and Synchronization in Concurrent OOP , 1987, ECOOP.

[74]  Pierre Cointe.  ECOOP ’96 — Object-Oriented Programming , 1996, Lecture Notes in Computer Science.