A survey of concurrent object-oriented languages
暂无分享,去创建一个
[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..