A survey of concurrent object-oriented languages

SUMMARY 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]  James R. Larus.  C**: A Large-Grain, Object-Oriented, Data-Parallel Programming Language , 1992, LCPC.

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

[3]  Andrew M. Lister.  The problem of nested monitor calls , 1977, OPSR.

[4]  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.

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

[6]  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.

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

[8]  K. Mani Chandy,et al.  Compositional C++: Compositional Parallel Programming , 1992, LCPC.

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

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

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

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

[13]  Pierre America.  Parallel database systems : PRISMA workshop, Noordwijk, The Netherlands, September 24-26, 1990 : proceedings , 1991 .

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

[15]  Dominique Decouchant.  Design of a distributed object manager for the Smalltalk-80 system , 1986, OOPSLA 1986.

[16]  Satoshi Matsuoka,et al.  Object-oriented concurrent reflective languages can be implemented efficiently , 1992, OOPSLA '92.

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

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

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

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

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

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

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

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

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

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

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

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

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

[30]  Zoran Budimac,et al.  A definition of an ISWIM-like language via scheme , 1993, SIGP.

[31]  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.

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

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

[34]  Gul Agha.  Proceedings of the ECOOP-OOPSLA Workshop on Object-Based Concurrent Programming Ottawa, Canada, October 21-22, 1990 , 1991 .

[35]  Nikitas A. Alexandridis.  Microsystems Special Monograph: Bit-Sliced Microprocessor Architecture , 1978, Computer.

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

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

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

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

[40]  Yasuhiko Yokote,et al.  The Design and Implementation of Concurrentsmalltalk , 1986, World Scientific Series in Computer Science.

[41]  Edsger W. Dijkstra,et al.  Cooperating sequential processes , 2002 .

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

[43]  Andrew S. Grimshaw,et al.  Easy-to-use object-oriented parallel processing with Mentat , 1993, Computer.

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

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

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

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

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

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

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

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

[52]  D. Decouchant,et al.  A synchronization mechanism for typed objects in a distributed system , 1988, OOPSLA/ECOOP '88.

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

[54]  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.

[55]  Aart J. C. Bik,et al.  Automatically exploiting implicit parallelism in Java , 1997 .

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

[57]  I. Foster,et al.  Integrating task and data parallelism , 1993, Supercomputing '93.

[58]  Paul L. McCullough.  Transparent forwarding: First steps , 1987, OOPSLA 1987.

[59]  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.

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

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

[62]  Jan van den Bos,et al.  Constraints in concurrent object-oriented environment , 1991, OOPS Messenger.

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

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

[65]  Gul A. Agha,et al.  Distributed Execution of Actor Programs , 1991, LCPC.

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

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

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

[69]  Jeff McAffer,et al.  Actra—an industrial strength concurrent object-oriented programming system , 1991, OOPSLA/ECOOP '90.

[70]  John K. Bennett.  The design and implementation of distributed Smalltalk , 1987, OOPSLA 1987.

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

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

[73]  Geoffrey C. Fox,et al.  Experiments with "HP Java" , 1997 .

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

[75]  Arjan J. C. van Gemund,et al.  Spar: A programming language for semi‐automatic compilation of parallel programs , 1997 .

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

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

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

[79]  Ken Kennedy,et al.  Fast interprocedual alias analysis , 1989, POPL '89.

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

[81]  Dennis G. Kafura,et al.  Recent progress in combining actor-based concurrency with object-oriented programming , 1991, OOPS Messenger.

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

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

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

[85]  Andrew A. Chien,et al.  Concurrent aggregates (CA) , 1990, PPOPP '90.

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

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

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

[89]  Craig Schaffert,et al.  An introduction to Trellis/Owl , 1986, OOPSLA 1986.

[90]  D. Kafura.  Concurrent object-oriented real-times systems research , 1988, OOPSLA/ECOOP '88.

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

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

[93]  Michael Philippsen,et al.  JavaParty – transparent remote objects in Java , 1997 .

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

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

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

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

[98]  M. Wei,et al.  CoSIDE and parallel object-oriented languages , 1992, OOPSLA '92.

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

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

[101]  Susan Horwitz,et al.  The first-course conundrum, why change? , 1995, CACM.

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

[103]  C. Manning.  A peek at Acore, an actor core language , 1988, OOPSLA/ECOOP '88.

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

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

[106]  Jan van den Bos,et al.  Propagators and concurrent constraints , 1991, OOPS Messenger.

[107]  Klaus-Peter Löhr.  Concurrency annotations , 1992, OOPSLA 1992.

[108]  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.

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

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

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

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

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

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

[115]  Gregory R. Andrews,et al.  A Language for Parallel and Distributed Programming , 1999 .

[116]  Andrew A. Chien.  Concurrent aggregates: using multiple-access data abstractions to manage complexity in concurrent programs , 1991, OOPS Messenger.

[117]  Peter de Jong,et al.  Concurrent organizational objects , 1991, OOPSLA/ECOOP Workshop on Object-based Concurrent Programming.

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

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

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

[121]  C. Tomlinson,et al.  Inheritance and Synchronization with Enabled Sets , 1989, OOPSLA.

[122]  Michael Philippsen,et al.  More efficient serialization and RMI for Java , 2000 .

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

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

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

[126]  Diane Crawford.  Technical correspondence: I. The equal-Means Case , 1994, CACM.

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

[128]  Gert Smolka.  The Definition of Kernel Oz , 1994 .

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

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

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

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

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

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

[135]  H. K. Birnbaum.  University of Illinois at Urbana-Champaign, Materials Research Laboratory progress report for FY 1993 and research proposal for FY 1994 , 1993 .

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

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

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

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

[140]  Mario Tokoro,et al.  An adaptive load balancing method in the computational field model , 1991, OOPS Messenger.

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

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

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

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

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

[146]  Alan L. Cox,et al.  Java/DSM: A platform for heterogeneous computing , 1997 .

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

[148]  Roy H. Campbell,et al.  The specification of process synchronization by path expressions , 1974, Symposium on Operating Systems.

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

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

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

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

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

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

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

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

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

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

[159]  Jacques Mossière,et al.  Persistent shared object support in the Guide system: evaluation & related work , 1994, OOPSLA 1994.

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

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

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

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

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

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

[166]  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.

[167]  D. A. Stewart,et al.  Harmony as an object-oriented operating system , 1988, OOPSLA/ECOOP '88.

[168]  Geoffrey C. Fox,et al.  HPJava: data parallel extensions to Java , 1998 .

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

[170]  Katherine Yelick,et al.  Titanium: a high-performance Java dialect , 1998 .

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

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

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

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

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

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

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

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

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

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

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

[182]  Denis Caromel.  A solution to the explicit/implicit control dilemma , 1991, OOPS Messenger.

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

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

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

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

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

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

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

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

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

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

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

[194]  Denis Caromel,et al.  Towards seamless computing and metacomputing in Java , 1998 .

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

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

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

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

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

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

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

[202]  Edward H. Bensley,et al.  The impact of selected concurrent language constructs on the Sam run-time system , 1991, OOPS Messenger.

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

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

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

[206]  Juris Hartmanis,et al.  The Programming Language Ada Reference Manual American National Standards Institute, Inc. ANSI/MIL-STD-1815A-1983 , 1983, Lecture Notes in Computer Science.

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

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

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

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

[211]  Robert R. Kessler,et al.  Distributed C++ , 1993, SIGP.

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

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

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

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

[216]  Oscar Nierstrasz.  Active objects in hybrid , 1987, OOPSLA 1987.