A survey of concurrent object-oriented languages

During the last decade object-oriented programming has grown from marginal influence into widespread acceptance. During the same period, progress in hardware and networking has changed the computing environment from sequential to parallel. Multi-processor workstations and clusters are now quite common. Unnumbered proposals have been made to combine both developments. Always the prime objective has been to provide the advantages of object-oriented software design at the increased power of parallel machines. However, combining both concepts has proven to be notoriously difficult. Depending on the approach, often key characteristics of either the object-oriented paradigm or key performance factors of parallelism are sacrificed, resulting in unsatisfactory languages. This survey first recapitulates well-known characteristics of both the object-oriented paradigm and parallel programming, and then marks out the design space of possible combinations by identifying various interdependencies of key concepts. The design space is then filled with data points: for 111 proposed languages we provide brief characteristics and feature tables. Feature tables, the comprehensive bibliography, and web-addresses might help in identifying open questions and preventing re-inventions. Copyright  2000 John Wiley & Sons, Ltd.

[1]  Henri E. Bal,et al.  Parallel programming using shared objects and broadcasting , 1992, Computer.

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

[3]  Vaidy S. Sunderam,et al.  IceT: Distributed Computing and Java , 1997, Concurr. Pract. Exp..

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

[5]  Marc Bourgois,et al.  Dynamic Programming as Multiagent Programming , 1991, Object-Based Concurrent Computing.

[6]  Luca Cardelli,et al.  A language with distributed scope , 1995, POPL '95.

[7]  Michael Philippsen,et al.  More efficient serialization and RMI for Java , 2000, Concurr. Pract. Exp..

[8]  J. van der Spek POOL-X and its Implementation , 1990, PRISMA Workshop.

[9]  Henri E. Bal,et al.  Object distribution in Orca using Compile-Time and Run-Time techniques , 1993, OOPSLA '93.

[10]  Anoop Gupta,et al.  Data locality and load balancing in COOL , 1993, PPOPP '93.

[11]  Gert Smolka,et al.  The Definition of Kernel Oz , 1994, Constraint Programming.

[12]  Hidehiko Tanaka,et al.  A Parallel Object Oriented Language FLENG++ and Its Control System on the Parallel Machine PIE64 , 1991, Concurrency: Theory, Language, And Architecture.

[13]  Krishna M. Kavi,et al.  Parallelism in object-oriented languages: a survey , 1992, IEEE Software.

[14]  A. Corradi,et al.  PO: an object model to express parallelism , 1988, OOPSLA/ECOOP '88.

[15]  V. Karamcheti,et al.  Concert-efficient runtime support for concurrent object-oriented programming languages on stock hardware , 1993, Supercomputing '93.

[16]  Denis Caromel,et al.  Object-Based Concurrency: Ten Language Features to Achieve Reuse , 1993, TOOLS.

[17]  Andrew A. Chien,et al.  Object-oriented concurrent programming in CST , 1989, ACM SIGPLAN Notices.

[18]  Jean-Marc Jézéquel,et al.  EPEE: an Eiffel Environment to Program Distributed Memory Parallel Computers , 1992, ECOOP.

[19]  K. Mani Chandy,et al.  CC++: A Declarative Concurrent Object Oriented Programming Notation , 1993 .

[20]  Michael Philippsen Enabling compiler transformations for pSather 1.1 , 1996 .

[21]  Mark Nuttall,et al.  A brief survey of systems providing process or object migration facilities , 1994, OPSR.

[22]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[23]  Serge Lacourte Exceptions in Guide, an Object-Oriented Language for Distributed Applications , 1991, ECOOP.

[24]  John Banning,et al.  : An Efficient , 2022 .

[25]  Laxmikant V. Kalé,et al.  CHARM++: a portable concurrent object oriented system based on C++ , 1993, OOPSLA '93.

[26]  Richard J. LeBlanc,et al.  Distributed Eiffel: a language for programming multi-granular distributed objects on the Clouds operating system , 1992, Proceedings of the 1992 International Conference on Computer Languages.

[27]  Anders Andersen,et al.  Concurrent Object Oriented Programming in Python with ATOM 1st Conference on Python , 1996 .

[28]  Mario Tokoro,et al.  An adaptive load balancing method in the computational field model , 1991, OOPSLA/ECOOP '90.

[29]  Louis H. Turcotte,et al.  A Survey of Software Environments for Exploiting Networked Computing Resources , 1993 .

[30]  Colin Atkinson,et al.  Object oriented concurrency and distribution in dragoon , 1991 .

[31]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[32]  Michel Riveill,et al.  Design and implementation of an object-oriented strongly typed language for distributed applications , 1990 .

[33]  Henri E. Bal,et al.  Comparing data synchronization in Ada 9X and Orca , 1995, ALET.

[34]  Andrew P. Black,et al.  Fine-grained mobility in the Emerald system , 1987, TOCS.

[35]  Oscar Nierstrasz,et al.  Active objects in hybrid , 1987, OOPSLA '87.

[36]  Won Kim,et al.  Comilation of a Highly Parallel Actor-Based Language , 1992, LCPC.

[37]  Gul A. Agha,et al.  ActorSpace: an open distributed programming paradigm , 1993, PPOPP '93.

[38]  Roger Lea,et al.  Supporting Object-Oriented Languages in a Distributed Environment: The COOL Approach , 1991, TOOLS.

[39]  Arjan J. C. van Gemund,et al.  Spar: A Programming Language for Semi-Automatic Compilation of Parallel Programs , 1997, Concurr. Pract. Exp..

[40]  Bruce K. Haddon Nested monitor calls , 1977, OPSR.

[41]  Henri E. Bal,et al.  Programming languages for distributed computing systems , 1989, CSUR.

[42]  Pierre America,et al.  Inheritance and Subtyping in a Parallel Object-Oriented Language , 1987, ECOOP.

[43]  Pierre America,et al.  A parallel object-oriented language with inheritance and subtyping , 1990, OOPSLA/ECOOP '90.

[44]  Kathleen M. Buyers,et al.  The Microelectronics and Computer Technology Corporation , 1989 .

[45]  Michael Papathomas,et al.  Language Design Rationale and Semantic Framework for Concurrent Object-Oriented Programming , 1992 .

[46]  Melvin E. Conway,et al.  A multiprocessor system design , 1899, AFIPS '63 (Fall).

[47]  Walter H. Kohler,et al.  Concurrency Features for the Trellis/Owl Language , 1987, ECOOP.

[48]  Per Brinch Hansen,et al.  Concurrent Programming Concepts , 1973, CSUR.

[49]  Michael Philippsen,et al.  Locality optimization in JavaParty by means of static type analysis , 2000 .

[50]  T. Chikayama,et al.  A'UM = Stream + Object + Relation , 1988, OOPSLA/ECOOP '88.

[51]  Katherine A. Yelick,et al.  Titanium: A High-performance Java Dialect , 1998, Concurr. Pract. Exp..

[52]  D. Caromel A general model for concurrent and distributed object-oriented programming , 1988, OOPSLA/ECOOP '88.

[53]  P. Mehrotra,et al.  Concurrent object access in BLAZE 2 , 1988, OOPSLA/ECOOP '88.

[54]  Pierre America POOL: design and experience , 1991, OOPS Messenger.

[55]  Michael Philippsen,et al.  JavaParty - Transparent Remote Objects in Java , 1997, Concurr. Pract. Exp..

[56]  Ken Kennedy,et al.  Fortran D Language Specification , 1990 .

[57]  Charles Antony Richard Hoare Towards a theory of parallel programming , 2002 .

[58]  John K. Bennett,et al.  The design and implementation of distributed Smalltalk , 1987, OOPSLA '87.

[59]  Russel L. Winder,et al.  CoSIDE and parallel object-oriented languages , 1993, OOPS Messenger.

[60]  米沢 明憲 ABCL : an object-oriented concurrent system , 1990 .

[61]  Utpal Banerjee,et al.  Dependence analysis for supercomputing , 1988, The Kluwer international series in engineering and computer science.

[62]  James R. Larus C**: A Large-Grain, Object-Oriented, Data-Parallel Programming Language , 1992, LCPC.

[63]  Sacha Krakowiak,et al.  A synchronization mechanism for typed objects in a distributed system , 1988, OOPSLA/ECOOP '88.

[64]  Donna S. Reese,et al.  Object oriented Fortran for development of portable parallel programs , 1991, Proceedings of the Third IEEE Symposium on Parallel and Distributed Processing.

[65]  Jeffrey S. Chase,et al.  The Amber system: parallel programming on a network of multiprocessors , 1989, SOSP '89.

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

[67]  Andrew A. Chien,et al.  Experience with CST: programming and implementation , 1989, PLDI '89.

[68]  Gail E. Kaiser,et al.  MELDing transactions and objects , 1991, OOPSLA/ECOOP '90.

[69]  Anoop Gupta,et al.  COOL: An object-based language for parallel programming , 1994, Computer.

[70]  Dennis Kafura,et al.  A class library for concurrent programming in c++ using actors , 1992 .

[71]  Andrew S. Grimshaw,et al.  Portable run-time support for dynamic object-oriented parallel processing , 1996, TOCS.

[72]  Chung-Kwong Yuen,et al.  A survey of implementations of concurrent, parallel and distributed Smalltalk , 1993, SIGP.

[73]  Chris Laffra,et al.  Constraints in concurrent object-oriented environments , 1991, OOPSLA/ECOOP '90.

[74]  Ole Lehrmann Madsen,et al.  Object-oriented programming in the BETA programming language , 1993 .

[75]  Wouter Joosen,et al.  Experiences with an Object-Oriented Parallel Language: The CORRELATE Project , 1997, ISCOPE.

[76]  Klaus-Peter Löhr Concurrency Annotations , 1992, OOPSLA.

[77]  Vineet Singh,et al.  Inheritance and synchronization with enabled-sets , 1989, OOPSLA '89.

[78]  Jenq Kuen Lee,et al.  Object oriented parallel programming: experiments and results , 1991, Proceedings of the 1991 ACM/IEEE Conference on Supercomputing (Supercomputing '91).

[79]  Gregg M. Townsend,et al.  SR : A Language for Parallel and Distributed Programming March 9 , 1992 , 1992 .

[80]  Jan van den Bos,et al.  PROCOL - A Parallel Object Language with Protocols , 1989, OOPSLA.

[81]  James R. Larus,et al.  LCM: memory system support for parallel language implementation , 1994, ASPLOS VI.

[82]  Andrew A. Chien,et al.  Concurrent Aggregates: Supporting Modularity in Massively Parallel Programs , 1993 .

[83]  Ken-ichi Maeda,et al.  Concurrent Object Oriented 'C' (cooC) , 1993, SIGP.

[84]  Emily A. West,et al.  Combining Control and Data Parallelism: Data Parallel Extensions to the Mentat Programming Language , 1994 .

[85]  Daniel Hagimont,et al.  Experience with shared object support in the GUIDE system , 1993 .

[86]  Jack B. Dennis,et al.  Programming semantics for multiprogrammed computations , 1966, CACM.

[87]  Michael D. Tiemann Solving the RPC problem in GNU C , 1993 .

[88]  Toby Bloom,et al.  Evaluating synchronization mechanisms , 1979, SOSP '79.

[89]  Andrew S. Grimshaw,et al.  Metasystems: An Approach Combining Parallel Processing and Heterogeneous Distributed Computing Systems , 1994, J. Parallel Distributed Comput..

[90]  Ole Lehrmann Madsen Building Abstractions for Concurrent Object-Oriented Programming , 1993 .

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

[92]  Rajive L. Bagrodia,et al.  MOOSE: A Concurrent Object-Oriented Language for Simulation , 1994, Int. J. Comput. Simul..

[93]  Guy Lapalme,et al.  SCOOP, Structured Concurrent Object-Oriented Prolog , 1988, ECOOP.

[94]  John D. McGregor,et al.  Understanding object-oriented: a unifying paradigm , 1990, CACM.

[95]  J.-P. Briot,et al.  From objects to actors: study of a limited symbiosis in smalltalk-80 , 1988, OOPSLA/ECOOP '88.

[96]  W. C. Athas,et al.  Cantor: an actor programming system for scientific computing , 1988, OOPSLA/ECOOP '88.

[97]  ListerAndrew The problem of nested monitor calls , 1977 .

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

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

[100]  Michael Papathomas,et al.  Concurrency Issues in Object-Oriented Programming Languages , 1989 .

[101]  Dennis G. Kafura,et al.  Inheritance in Actor Based Concurrent Object-Oriented Languages , 1989, Comput. J..

[102]  Thomas Breitbach,et al.  PANDA - Supporting Distributed Programming in C++ , 1993, ECOOP.

[103]  C. Atkinson,et al.  Dragoon: an object-oriented notation supporting the reuse and distribution of Ada software , 1990, IRTAW '90.

[104]  Peter A. Buhr,et al.  Adding Concurrency to a Programming Language , 1992, C++ Conference.

[105]  A. A. Chien,et al.  Object-oriented concurrent programming in CST , 1988, C3P.

[106]  Dennis Kafura,et al.  ACT++: Building a Concurrent C++ with Actors , 1989 .

[107]  Gul A. Agha,et al.  Open Heterogeneous Computing in Actor Space , 1994, J. Parallel Distributed Comput..

[108]  Edsger W. Dijkstra,et al.  Guarded commands, nondeterminacy and formal derivation of programs , 1975, Commun. ACM.

[109]  Takanobu Baba,et al.  A network-topology independent task allocation strategy for parallel computers , 1990, Proceedings SUPERCOMPUTING '90.

[110]  Andrew S. Grimshaw The Mentat Computation Model Data-Driven Support for Object-Oriented Parallel Processing , 1993 .

[111]  Satoshi Matsuoka,et al.  An Object-Oriented Concurrent Re ective Language for Dynamic Resource Management in Highly Parallel Computing , 1992 .

[112]  S. J. Young,et al.  The programming language ADA reference manual: Springer-Verlag (1981) pp 243, $7.90, DM 16.50 , 1982, Microprocess. Microsystems.

[113]  Peter A. Buhr,et al.  μC++: Concurrency in the object‐oriented language C++ , 1992, Softw. Pract. Exp..

[114]  Gul A. Agha,et al.  HAL: A High-Level Actor Language and Its Distributed Implementation , 1992, ICPP.

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

[116]  Seán Baker,et al.  Scheduling Predicates , 1991, Object-Based Concurrent Computing.

[117]  Dennis Kafura,et al.  Recent progress in combining actor-based concurrency with object-oriented programming , 1991, OOPSLA/ECOOP '90.

[118]  Bruno Achauer,et al.  Implementation of Distributed Trellis , 1993, ECOOP.

[119]  Jerome A. Feldman,et al.  Portable, modular expression of locality , 1997 .

[120]  Rachid Guerraoui Dealing with atomicity in object-based distributed systems , 1992, OOPS.

[121]  D. Caromel A solution to the explicit/implicit control dilemma , 1991, OOPSLA/ECOOP '90.

[122]  Oscar Nierstrasz,et al.  A Tour of Hybrid A Language for Programming with Active Objects , 1992 .

[123]  Luca Cardelli,et al.  Obliq, a language with distributed scope , 1996 .

[124]  Andrew A. Chien,et al.  Obtaining sequential efficiency for concurrent object-oriented languages , 1995, POPL '95.

[125]  Alan L. Cox,et al.  Java/DSM: A Platform for Heterogeneous Computing , 1997, Concurr. Pract. Exp..

[126]  Murat Karaorman,et al.  Design and Implementation Issues for Object-Oriented Concurrency , 1993 .

[127]  Edward H. Bensley,et al.  The impact of selected concurrent language constructs on the Sam run-time system , 1991, OOPSLA/ECOOP '90.

[128]  Dennis Gannon,et al.  Distributed pC++ Basic Ideas for an Object Parallel Language , 1993, Sci. Program..

[129]  Mesaac Makpangou,et al.  Fragmented Objects for Distributed Abstractions , 1994 .

[130]  C. Tomlinson,et al.  Rosette: An object-oriented concurrent systems architecture , 1988, OOPSLA/ECOOP '88.

[131]  Alan Borning,et al.  Classes versus Prototypes in Object-Oriented Languages , 1986, FJCC.

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

[133]  Bruno Achauer,et al.  The DOWL distributed object-oriented language , 1993, CACM.

[134]  Anoop Gupta,et al.  COOL: a language for parallel programming , 1990 .

[135]  Denis Caromel A general model for concurrent and distributed object-oriented programming , 1989, ACM SIGPLAN Notices.

[136]  Marc Shapiro,et al.  FOG/C++: A Fragmented Object Generator , 1990, C++ Conference.

[137]  Michael Philippsen,et al.  Locality optimization in JavaParty by means of static type analysis , 2000, Concurr. Pract. Exp..

[138]  Brian N. Bershad,et al.  PRESTO: A system for object‐oriented parallel programming , 1988, Softw. Pract. Exp..

[139]  Mario Tokoro,et al.  DROL: an object-oriented programming language for distributed real-time systems , 1992, OOPSLA.

[140]  Barbara G. Ryder,et al.  Interprocedural modification side effect analysis with pointer aliasing , 1993, PLDI '93.

[141]  Ian Foster,et al.  Designing and building parallel programs , 1994 .

[142]  Gregory R. Andrews,et al.  Synchronizing Resources , 1981, TOPL.

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

[144]  David F. Bacon,et al.  Compiler transformations for high-performance computing , 1994, CSUR.

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

[146]  Horst D. Wettstein The problem of nested monitor calls revisited , 1978, OPSR.

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

[148]  Vaidy S. Sunderam,et al.  Concurrent programming with shared objects in networked environments , 1993, [1993] Proceedings Seventh International Parallel Processing Symposium.

[149]  Gail E. Kaiser,et al.  MELDC: A Reflective Object-Oriented Coordination Language , 1993 .

[150]  Doreen Y. Cheng,et al.  A Survey of Parallel Programming Languages and Tools , 2001 .

[151]  Hiroaki Nakamura,et al.  Concurrent Programming in COB , 1989, Concurrency: Theory, Language, And Architecture.

[152]  Birger Andersen,et al.  Ellie: a general, fine-grained, first-class, object-based language , 1992 .

[153]  Daniel T. Chang CORAL: a concurrent object-oriented system for constructing and executing sequential, parallel and distributed applications , 1991, OOPSLA/ECOOP '90.

[154]  Mario Tokoro,et al.  The design and implementation of Concurrent Smalltalk , 1986, OOPLSA '86.

[155]  Dennis Kafura,et al.  Concurrent Object-Oriented Languages and the Inheritance Anomaly , 1993 .

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

[157]  Takanobu Baba,et al.  A parallel object-oriented language A-NETL and its programming environment , 1991, [1991] Proceedings The Fifteenth Annual International Computer Software & Applications Conference.

[158]  A. Malony,et al.  Implementing a parallel C++ runtime system for scalable parallel systems , 1993, Supercomputing '93.

[159]  Satoshi Matsuoka,et al.  ABCL/f: A Future-Based Polymorphic Typed Concurrent Object-Oriented Language- Its Design and Implementation , 1994, Specification of Parallel Algorithms.

[160]  Giuseppe Castagna,et al.  Covariance and contravariance: conflict without a cause , 1995, TOPL.

[161]  Peter A. Buhr Are Safe Concurrency Libraries Possible? , 1995, Commun. ACM.

[162]  A. S. Grimshaw,et al.  Braid: integrating task and data parallelism , 1995, Proceedings Frontiers '95. The Fifth Symposium on the Frontiers of Massively Parallel Computation.

[163]  Bertrand Meyer,et al.  Applying 'design by contract' , 1992, Computer.

[164]  Stephen S. Yau,et al.  An object-oriented approach to software development for parallel processing systems , 1991, [1991] Proceedings The Fifteenth Annual International Computer Software & Applications Conference.

[165]  Dennis G. Kafura Concurrent object-oriented real-times systems research , 1989, ACM SIGPLAN Notices.

[166]  Chris Laffra,et al.  Propagators and concurrent constraints , 1991, OOPSLA/ECOOP '90.

[167]  Robert R. Kessler,et al.  Compiling distributed C++ , 1993, Proceedings of 1993 5th IEEE Symposium on Parallel and Distributed Processing.

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

[169]  Jason Maassen,et al.  An efficient implementation of Java's remote method invocation , 1999, PPoPP '99.

[170]  Gregory R. Andrews,et al.  The SR programming language: concurrency in practice , 1993 .

[171]  Carl Manning A peek at Acore, an actor core language , 1989, ACM SIGPLAN Notices.

[172]  Andrew A. Chien Concurrent aggregates: using multiple-access data abstractions to manage complexity in concurrent programs , 1991, OOPSLA/ECOOP '90.

[173]  Klaus-Peter Löhr Concurrency annotations for reusable software , 1993, CACM.

[174]  Edsger W. Dijkstra,et al.  The structure of the “THE”-multiprogramming system , 1968, CACM.

[175]  Jong-Deok Choi,et al.  Efficient flow-sensitive interprocedural computation of pointer-induced aliases and side effects , 1993, POPL '93.

[176]  Kilnam Chon,et al.  Overview of a Parallel Object-Oriented Language CLIX , 1987, ECOOP.

[177]  Marcel Schelvis,et al.  The Implementation of a Distributed Smalltalk , 1988, ECOOP.

[178]  J. H. Huang,et al.  A distributed Smalltalk based on process-object model , 1991, [1991] Proceedings The Fifteenth Annual International Computer Software & Applications Conference.

[179]  Per Brinch Hansen,et al.  Operating System Principles , 1973 .

[180]  Roldan Pozo A stream-based interface in C++ for programming heterogeneous systems , 1993 .

[181]  P. de Jong,et al.  Concurrent organizational objects , 1991, OOPSLA/ECOOP '90.

[182]  Sacha Krakowiak,et al.  Persistent shared object support in the Guide system: evaluation & related work , 1994, OOPSLA '94.

[183]  Giulio Iannello,et al.  Implementing actor-based primitives on distributed-memory architectures , 1991, OOPS Messenger.

[184]  Guy L. Steele,et al.  The High Performance Fortran Handbook , 1993 .

[185]  Gert Smolka,et al.  Object-Oriented Concurrent Constraint Programming in Oz , 1993, KI.

[186]  J. McAffer,et al.  Actra-a multitasking/multiprocessing smalltalk , 1988, OOPSLA/ECOOP '88.

[187]  Gail E. Kaiser,et al.  Multiple concurrency control policies in an object-oriented programming system , 1990, Proceedings of the Second IEEE Symposium on Parallel and Distributed Processing 1990.

[188]  Darlene A. Stewart,et al.  Harmony as an object-oriented operating system , 1989, ACM SIGPLAN Notices.

[189]  Peter Van Roy,et al.  An overview of the design of Distributed Oz , 1997, PASCO '97.

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

[191]  B. Hindel An object-oriented programming language for distributed systems: Heraklit , 1988, OOPSLA/ECOOP '88.

[192]  Hayssam Saleh,et al.  A Concurrency Control Mechanism for C++ Objects , 1991, Object-Based Concurrent Computing.

[193]  Luca Cardelli,et al.  On understanding types, data abstraction, and polymorphism , 1985, CSUR.

[194]  Craig Schaffert,et al.  An introduction to Trellis/Owl , 1986, OOPLSA '86.

[195]  R. H. H. Wester,et al.  The POOMA operating system , 1991, PRISMA Workshop.

[196]  Paul L. McCullough Transparent forwarding: First steps , 1987, OOPSLA '87.

[197]  W DijkstraEdsger The structure of the THE-multiprogramming system , 1968 .

[198]  A. S. Grimshaw,et al.  FALCON: A distributed scheduler for MIMD architectures , 1991 .

[199]  Jeff McAffer,et al.  Actra - an industrial strength concurrent object-oriented programming system , 1991, OOPS Messenger.

[200]  Tzilla Elrad,et al.  Coordinating Distributed Objects , 1999, PDPTA.

[201]  Jean-Marc Jézéquel,et al.  A multi-paradigm object oriented parallel environment , 1994, Proceedings of 8th International Parallel Processing Symposium.

[202]  Joep L. W. Kessels An alternative to event queues for synchronization in monitors , 1977, CACM.

[203]  Piyush Mehrotra,et al.  The BLAZE language: A parallel language for scientific programming , 1987, Parallel Comput..

[204]  Per Brinch Hansen,et al.  Structured multiprogramming , 1972, CACM.

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

[206]  Michael Philippsen,et al.  Imperative Concurrent Object-Oriented Languages: An Annotated Bibliography , 1995 .

[207]  Norihisa Doi,et al.  The design and implementation of HoME , 1992, PLDI '92.

[208]  Roy H. Campbell,et al.  Synchronizing shared objects , 1995, Distributed Syst. Eng..

[209]  Dominique Decouchant,et al.  Design of a distributed object manager for the Smalltalk-80 system , 1986, OOPLSA '86.

[210]  Mary E. Mace Memory storage patterns in parallel processing , 1987, The Kluwer international series in engineering and computer science.

[211]  Geoffrey C. Fox,et al.  HPJava: Data Parallel Extensions to Java , 1998, Concurr. Pract. Exp..

[212]  Satoshi Matsuoka,et al.  Object-Oriented Concurrent Reflective Languages can be Implemented Efficiently , 1992, OOPSLA.

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

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

[215]  D. Boles Parallel Object-Oriented Programming with QPC++ , 1993, Struct. Program..

[216]  David M. Ungar,et al.  Multiprocessor Smalltalk: a case study of a multiprocessor-based programming environment , 1988, PLDI '88.

[217]  Henri E. Bal,et al.  A comparative study of five parallel programming languages , 1992, Future Gener. Comput. Syst..