Programming languages for distributed computing systems

When distributed systems first appeared, they were programmed in traditional sequential languages, usually with the addition of a few library procedures for sending and receiving messages. As distributed applications became more commonplace and more sophisticated, this ad hoc approach became less satisfactory. Researchers all over the world began designing new programming languages specifically for implementing distributed applications. These languages and their history, their underlying principles, their design, and their use are the subject of this paper. We begin by giving our view of what a distributed system is, illustrating with examples to avoid confusion on this important and controversial point. We then describe the three main characteristics that distinguish distributed programming languages from traditional sequential languages, namely, how they deal with parallelism, communication, and partial failures. Finally, we discuss 15 representative distributed languages to give the flavor of each. These examples include languages based on message passing, rendezvous, remote procedure call, objects, and atomic transactions, as well as functional languages, logic languages, and distributed data structure languages. The paper concludes with a comprehensive bibliography listing over 200 papers on nearly 100 distributed programming languages.

[1]  P. Hudak Exploring parafunctional programming: separating the what from the how , 1988, IEEE Software.

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

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

[4]  Edward William. Vopata Distributed discrete-event simulation in Concurrent C , 1989 .

[5]  Sartaj Sahni,et al.  Programming a hypercube multicomputer , 1988, IEEE Software.

[6]  Per Brinch Hansen,et al.  Distributed processes: a concurrent programming concept , 1978, CACM.

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

[8]  Inmos Limited,et al.  Occam Programming Manual , 1984 .

[9]  Abraham Silberschatz,et al.  Comments on “Communicating Sequential Processes” , 1979, TOPL.

[10]  E. B. Moss,et al.  Nested Transactions: An Approach to Reliable Distributed Computing , 1985 .

[11]  Richard J. LeBlanc,et al.  Distributed locking: a mechanism for constructing highly available objects , 1988, Proceedings [1988] Seventh Symposium on Reliable Distributed Systems.

[12]  Paul Hudak Para-Functional Programming , 1986, Computer.

[13]  David Gelernter A Note on Systems Programming in Concurrent Prolog , 1984, SLP.

[14]  M. Collado,et al.  A PROGRAMMING LANGUAGE FOR DISTRIBUTED SYSTEMS , 1987 .

[15]  J. M. Adamo,et al.  PASCAL + CSP, Merging PASCAL and CSP in a parallel processing oriented language , 1982, ICDCS.

[16]  L. W. Ericson,et al.  DPL-82: A language for distributed processing , 1982, ICDCS.

[17]  A. J. Fisher A multi‐processor implementation of occam , 1986, Softw. Pract. Exp..

[18]  Guy T. Almes,et al.  The Impact of Language and System on Remote Procedure Call Design , 1986, ICDCS.

[19]  R. Strom,et al.  NIL: An integrated language and system for distributed programming , 1983, SIGPLAN '83.

[20]  Chang Li,et al.  Concurrent programming language—LISPTALK , 1988, SIGP.

[21]  Henri E. Bal,et al.  Distributed programming with shared data , 1988, Proceedings. 1988 International Conference on Computer Languages.

[22]  Thomas J. LeBlanc,et al.  An analysis of language models for high-performance communication in local-area networks , 1983, SIGPLAN '83.

[23]  Ehud Shapiro,et al.  A Sequential Abstract Machine for Flat Concurrent Prolog , 1989, J. Log. Program..

[24]  BackusJohn Can programming be liberated from the von Neumann style , 1978 .

[25]  Narain H. Gehani,et al.  The concurrent C programming language , 1989 .

[26]  Abraham Silberschatz,et al.  Cell: A Distributed Computing Modularization Concept , 1984, IEEE Transactions on Software Engineering.

[27]  R. V. Renesse,et al.  Implementing distributed algorithms using remote procedure calls , 1987 .

[28]  David Gelernter,et al.  Parallelism, persistence and meta-cleanliness in the symmetric Lisp interpreter , 1987, PLDI 1987.

[29]  Suresh Jagannathan,et al.  Environments as first class objects , 1987, POPL '87.

[30]  Narain H. Gehani,et al.  Broadcasting Sequential Processes (BSP) , 1984, IEEE Transactions on Software Engineering.

[31]  Richard P. Hopkins,et al.  Data-Driven and Demand-Driven Computer Architecture , 1982, CSUR.

[32]  Satoshi Matsuoka,et al.  Using tuple space communication in distributed object-oriented languages , 1988, OOPSLA 1988.

[33]  Inmos Corp,et al.  Occam Programming Manual , 1984 .

[34]  Kenneth P. Birman,et al.  Low cost management of replicated data in fault-tolerant distributed systems , 1986, TOCS.

[35]  Ian T. Foster,et al.  Parallel Implementation of Parlog , 1988, International Conference on Parallel Processing.

[36]  Paul Hudak,et al.  Memory coherence in shared virtual memory systems , 1986, PODC '86.

[37]  Gregory R. Andrews,et al.  An overview of the SR language and implementation , 1988, TOPL.

[38]  Udi Manber,et al.  DIB—a distributed implementation of backtracking , 1987, TOPL.

[39]  D. Crookes,et al.  An experiment in language design for distributed systems , 1984, Softw. Pract. Exp..

[40]  共立出版株式会社 コンピュータ・サイエンス : ACM computing surveys , 1978 .

[41]  Steven E. Lucco Parallel programming in a virtual object space , 1987, OOPSLA 1987.

[42]  Petter E. Bjørstad,et al.  A large scale, sparse, secondary storage, direct linear equation solver for structural analysis and its implementation on vector and parallel architectures , 1987, Parallel Comput..

[43]  Narain H. Gehani,et al.  Experience with Multiple Processor Versions of Concurrent C , 1989, IEEE Trans. Software Eng..

[44]  K. Mani Chandy,et al.  A Micro-Kernel for Distributed Applications , 1985, ICDCS.

[45]  Andrew S. Tanenbaum,et al.  A practical tool kit for making portable compilers , 1983, Commun. ACM.

[46]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[47]  Jeff Magee,et al.  Dynamic Configuration for Distributed Systems , 1985, IEEE Transactions on Software Engineering.

[48]  Tzilla Elrad,et al.  Distributed Languages Design Constructs for Controlling Preferences , 1986, ICPP.

[49]  Ingemar J. Cox,et al.  Concurrent Programming and Robotics , 1989, Int. J. Robotics Res..

[50]  Ehud Shapiro,et al.  Concurrent Prolog: A Progress Report , 1985, Computer.

[51]  Stefan Eicholz,et al.  Parallel Programming with ParMod , 1987, International Conference on Parallel Processing.

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

[53]  Keith L. Clark,et al.  PARLOG: parallel programming in logic , 1986, ACM Trans. Program. Lang. Syst..

[54]  Butler W. Lampson,et al.  Atomic Transactions , 1980, Advanced Course: Distributed Systems.

[55]  Ehud Shapiro,et al.  Concurrent PROLOG: Collected Papers , 1987 .

[56]  Masahiko Sato,et al.  Quty: A Concurrent Language Based on Logic and Function , 1988, International Conference on Logic Programming.

[57]  Ware Myers Ada: First Users-Pleased; Prospective Users-Still Hesitant , 1987, Computer.

[58]  Narain H. Gehani,et al.  Concurrent C , 1986, Softw. Pract. Exp..

[59]  Steve Gregory,et al.  Parallel logic programming in parlo9 , 1987 .

[60]  Narain H. Gehani,et al.  Rendezvous Facilities: Concurrent C and the Ada Language , 1988, IEEE Trans. Software Eng..

[61]  Rong Yang P-Prolog - A Parallel Logic Programming Language , 1988, World Scientific Series in Computer Science.

[62]  Gul Agha An overview of actor languages , 1986 .

[63]  Al Davis,et al.  The Architecture of the FAIM-1 Symbolic Multiprocessing System , 1985, IJCAI.

[64]  Narain H. Gehani,et al.  Fault tolerant concurrent C: a tool for writing fault tolerant distributed programs , 1988, [1988] The Eighteenth International Symposium on Fault-Tolerant Computing. Digest of Papers.

[65]  Henri E. Bal,et al.  Implementing Distributed Algortihms using Remote Procedure Call , 1899 .

[66]  Shigeo Sugimoto,et al.  A Multi-Microprocessor System for Concurrent LISP , 1983, ICPP.

[67]  A. S. Xu,et al.  A FAULT-TOLERANT NETWORK KERNEL FOR LINDA , 1988 .

[68]  Maurice Herlihy,et al.  Inheritance of synchronization and recovery properties in Avalon/C++ , 1988, Computer.

[69]  Gruia-Catalin Roman,et al.  Toward Comprehensive Specification of Distributed Systems , 1987, ICDCS.

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

[71]  Prasad Vishnubhotla,et al.  Synchronization and scheduling in ALPS objects , 1988, [1988] Proceedings. The 8th International Conference on Distributed.

[72]  Kazunori Ueda,et al.  Guarded Horn Clauses , 1986, LP.

[73]  Rob Strom,et al.  A comparison of the object-oriented and process paradigms , 1986, OOPWORK '86.

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

[75]  Jonathan Schaeffer,et al.  Multiprocessor tree-search experiments , 1986 .

[76]  John H. Reppy Synchronous operations as first-class values , 1988, PLDI '88.

[77]  Mario Tokoro,et al.  Experience and evolution of concurrent Smalltalk , 1987, OOPSLA 1987.

[78]  Keith L. Clark,et al.  PARLOG and Its Applications , 1988, IEEE Trans. Software Eng..

[79]  Luís Moniz Pereira,et al.  Delta Prolog: A Distributed Backtracking Extension with Events , 1986, ICLP.

[80]  David L. Presotto,et al.  Publishing: a reliable broadcast communication mechanism , 1983, SOSP '83.

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

[82]  Akikazu Takeuchi,et al.  Parallel Logic Programming Languages , 1986, ICLP.

[83]  Narain H. Gehani,et al.  Concurrent programming in the Ada® language: The polling bias , 1984, Softw. Pract. Exp..

[84]  Andrew P. Black,et al.  The Eden System: A Technical Review , 1985, IEEE Transactions on Software Engineering.

[85]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[86]  Brian W. Kernighan,et al.  The C Programming Language , 1978 .

[87]  Alfred Z. Spector,et al.  The Camelot project , 1986 .

[88]  Zhongxiu Sun,et al.  CSM: A Distributed Programming Language , 1987, IEEE Trans. Software Eng..

[89]  Boontee Kruatrachue,et al.  Grain size determination for parallel processing , 1988, IEEE Software.

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

[91]  Paul Hudak,et al.  Para-functional programming: a paradigm for programming multiprocessor systems , 1986, POPL '86.

[92]  Richard J. LeBlanc,et al.  System Programming with Objects and Actions , 1985, ICDCS.

[93]  Robert E. Strom,et al.  Optimistic recovery in distributed systems , 1985, TOCS.

[94]  Chris J. Barter,et al.  A communicating sequential process language and implementation , 1981, Softw. Pract. Exp..

[95]  J. L. Albright,et al.  Early experience. , 1987, The Veterinary clinics of North America. Food animal practice.

[96]  Per Brinch Hansen,et al.  The programming language Concurrent Pascal , 1975, IEEE Transactions on Software Engineering.

[97]  Morris Sloman,et al.  Distributed systems and computer networks , 1987, Prentice Hall International series in computer science.

[98]  Mario Tokoro,et al.  Experience and Evolution of ConcurrentSmalltalk , 1987, OOPSLA.

[99]  Jr. Nicholas John Carriero Implementation of tuple space machines , 1987 .

[100]  Carl Hewitt,et al.  Viewing Control Structures as Patterns of Passing Messages , 1977, Artif. Intell..

[101]  Michael L. Scott,et al.  Language Support for Loosely Coupled Distributed Programs , 1987, IEEE Transactions on Software Engineering.

[102]  Peter M. Schwarz,et al.  Experience Using Multiprocessor Systems—A Status Report , 1980, CSUR.

[103]  Nicholas Carriero,et al.  Matching Language and Hardware for Parallel Computation in the Linda Machine , 1988, IEEE Trans. Computers.

[104]  Norman C. Hutchinson,et al.  EMERALD: An object-based language for distributed programming , 1987 .

[105]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[106]  Paul Hudak,et al.  Alfalfa: Distributed graph reduction on a hypercube multiprocessor , 1986, Graph Reduction.

[107]  Andrew Birrell,et al.  Implementing remote procedure calls , 1984, TOCS.

[108]  William E. Weihl,et al.  Implementation of resilient, atomic data types , 1985, TOPL.

[109]  Robert P. Cook,et al.  *MOD—A Language for Distributed Programming , 1980, IEEE Transactions on Software Engineering.

[110]  Maurice Herlihy,et al.  A Value Transmission Method for Abstract Data Types , 1982, TOPL.

[111]  Per Brinch Hansen,et al.  Joyce—A programming language for distributed systems , 1987, Softw. Pract. Exp..

[112]  Pierre Jouvelot,et al.  The FX-87 Interpreter , 1988, Proceedings. 1988 International Conference on Computer Languages.

[113]  James H. Morris,et al.  Early experience with Mesa , 1977 .

[114]  Friedemann Mattern,et al.  Key Concepts of the INCAS Multicomputer Project , 1987, IEEE Transactions on Software Engineering.

[115]  Jon M. Kerridge,et al.  Communicating parallel processes , 1986, Softw. Pract. Exp..

[116]  Barbara Liskov,et al.  Distributed programming in Argus , 1988, CACM.

[117]  Nicholas Carriero,et al.  Distributed data structures in Linda , 1986, POPL '86.

[118]  Arthur B. Maccabe,et al.  The design of a programming language based on connectivity networks , 1982, ICDCS.

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

[120]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[121]  William E. Weihl,et al.  Atomic data abstractions in a distributed collaborative editing system , 1986, POPL '86.

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

[123]  Suresh Jagannathan,et al.  Parallelism, persistence and meta-cleanliness in the symmetric Lisp interpreter , 1987, PLDI.

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

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

[126]  Ian T. Foster,et al.  A Sequential Implementation of Parlog , 1986, ICLP.

[127]  J. A. Robinson,et al.  A Machine-Oriented Logic Based on the Resolution Principle , 1965, JACM.

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

[129]  Brian E. Carpenter,et al.  Experience with remote procedure calls in a real‐time control system , 1984, Softw. Pract. Exp..

[130]  Barbara Liskov,et al.  On Linguistic Support for Distributed Programs , 1982, IEEE Transactions on Software Engineering.

[131]  B. R. Badrinath,et al.  Implementation of CSP-S for Description of Distributed Algorithms , 1984, Comput. Lang..

[132]  Alan Burns,et al.  A Review of Ada Tasking , 1987, Lecture Notes in Computer Science.

[133]  Bruce Jay Nelson Remote procedure call , 1981 .

[134]  Mario Tokoro,et al.  Orient84/K: an object-oriented concurrent programming language for knowledge representation , 1987 .

[135]  H. T. Kung Why systolic architectures? , 1982, Computer.

[136]  Arthur J. Bernstein,et al.  Output Guards and Nondeterminism in “Communicating Sequential Processes” , 1980, TOPL.

[137]  John McCarthy,et al.  Queue-based multi-processing LISP , 1984, LFP '84.

[138]  Ehud Shapiro,et al.  Meta interpreters for real , 1988 .

[139]  C. A. R. Hoare,et al.  The emperor's old clothes , 1981, CACM.

[140]  Nobuki Tokura,et al.  Concurrent C: A programming language for distributed multiprocessor systems , 1984, Softw. Pract. Exp..

[141]  Kam-Wing Ng,et al.  GDPL - A Generalized Distributed Programming Language , 1984, ICDCS.

[142]  Paul Hudak,et al.  Memory coherence in shared virtual memory systems , 1989, TOCS.

[143]  Narain H. Gehani,et al.  Concurrent C++: Concurrent programming with class(es) , 1988, Softw. Pract. Exp..

[144]  Andrew S. Tanenbaum,et al.  Distributed operating systems , 2009, CSUR.

[145]  David A. Fisher,et al.  Parallel Processing in Ada , 1986, Computer.

[146]  Craig Schaffert,et al.  Abstraction mechanisms in CLU , 1977, Commun. ACM.

[147]  Gregory R. Andrews,et al.  The distributed programming language SR—Mechanisms, design and implementation , 1982, Softw. Pract. Exp..

[148]  John F. Wakerly,et al.  The programming language PASCAL , 1979, Microprocessors and microsystems.

[149]  Erik H. Baalbergen Design and Implementation of Parallel Make , 1988, Comput. Syst..

[150]  Butler W. Lampson,et al.  Distributed Systems - Architecture and Implementation, An Advanced Course , 1981, Advanced Course: Distributed Systems.

[151]  F. Halsall,et al.  Design and implementation of a C-based language for distributed real-time systems , 1987, SIGP.

[152]  Jerome A. Feldman,et al.  High level programming for distributed computing , 1979, CACM.

[153]  Andrew S. Tanenbaum,et al.  Operating systems: design and implementation , 1987, Prentice-Hall software series.

[154]  Daniel G. Bobrow,et al.  Objects in Concurrent Logic Programming Languages , 1986, OOPSLA.

[155]  R. F. Kamel,et al.  Remote rendezvous , 1987, Softw. Pract. Exp..

[156]  David Gelernter,et al.  Generative communication in Linda , 1985, TOPL.

[157]  M. S. Day REPLICATION AND RECONFIGURATION IN A DISTRIBUTED MAIL REPOSITORY , 1987 .

[158]  Kenneth P. Birman,et al.  Reliable communication in the presence of failures , 1987, TOCS.

[159]  Alan L. Cox,et al.  An Empirical Study of Message-Passing Overhead , 1986 .

[160]  Shang Lujun,et al.  An object-oriented programming language for developing distributed software , 1987 .

[161]  Rong Yang,et al.  P-Prolog: A Parallel Logic Language Based on Exclusive Relation , 1986, ICLP.

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

[163]  Eric Jul Object mobility in a distributed object-oriented system , 1990 .

[164]  Mario Tokoro,et al.  Object-oriented concurrent programming , 1987 .

[165]  Keith L. Clark,et al.  A relational language for parallel programming , 1981, FPCA '81.

[166]  Robert H. Halstead,et al.  MULTILISP: a language for concurrent symbolic computation , 1985, TOPL.

[167]  Michael Lee Scott Design and implementation of a distributed systems language (crystal, charlotte, lynx, soda) , 1985 .

[168]  David Harel,et al.  Horn Clauses Queries and Generalizations , 1985, J. Log. Program..

[169]  Michael Goldsmith,et al.  Programming in occam 2 , 1985, Prentice Hall international series in computer science.

[170]  Michael L. Scott The Interface Between Distributed Operating System and High-Level Programming Language , 1986, ICPP.

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

[172]  T. S. E. Maibaum,et al.  A message oriented language for system applications , 1982, ICDCS.

[173]  Barbara Liskov,et al.  Implementation of Argus , 1987, SOSP '87.

[174]  Peter Wegner,et al.  Viewing Ada from a process model perspective , 1985, SIGAda '85.

[175]  Ehud Shapiro,et al.  A subset of Concurrent Prolog and its interpreter , 1988 .

[176]  Sun Zhongxiu,et al.  CSM: A Distributed Programming Language , 1987, IEEE Transactions on Software Engineering.

[177]  Charles L. Seitz,et al.  Multicomputers: message-passing concurrent computers , 1988, Computer.

[178]  Satoshi Matsuoka,et al.  Using tuple space communication in distributed object-oriented languages , 1988, OOPSLA '88.

[179]  Jørgen Staunstrup,et al.  Message passing communication versus procedure call communication , 1982, Softw. Pract. Exp..

[180]  Ehud Shapiro Systolic Programming: A Paradigm of Parallel Processing , 1984, FGCS.

[181]  Andrew P. Black,et al.  Object structure in the Emerald system , 1986, OOPLSA '86.

[182]  Alan Burns,et al.  Pascal-FC: a language for teaching concurrent programming , 1988, SIGP.

[183]  Nicholas Carriero,et al.  Applications experience with Linda , 1988, PPoPP 1988.

[184]  Polle Zellweger,et al.  The structure of Cedar , 1985, ACM SIGPLAN Notices.

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

[186]  Jaroslaw Milewski Loslan implementation of the AMPL message-passing system , 1984, SIGP.

[187]  Eric C. Cooper Replicated distributed programs , 1985, SOSP 1985.

[188]  W. F. Burger,et al.  Gypsy: A language for specification and implementation of verifiable programs , 1977, Language Design for Reliable Software.

[189]  G. Agha An overview of actor languages , 1986, OOPWORK '86.

[190]  Nicholas Carriero,et al.  Applications experience with Linda , 1988, PPEALS '88.

[191]  Edwin H. Satterthwaite,et al.  Early experience with Mesa , 1977, CACM.

[192]  Richard C. Holt A short introduction to Concurrent Euclid , 1982, SIGP.

[193]  Robert E. Strom,et al.  Typestate: A programming language concept for enhancing software reliability , 1986, IEEE Transactions on Software Engineering.

[194]  Steve Gregory,et al.  Parallel logic programming in PARLOG - the language and its implementation , 1987 .

[195]  Steven Lucco,et al.  Parallel programming in a virtual object space , 1987, OOPSLA '87.

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

[197]  Keith L. Clark,et al.  Notes on the Implementation of Parlog , 1985, J. Log. Program..

[198]  Roger B. Dannenberg,et al.  AMPL: Design, Implementation, and Evaluation of a Multiprocessing Language , 1981 .

[199]  F. Warren Burton,et al.  Annotations to Control Parallelism and Reduction Order in the Distributed Evaluation of Functional Programs , 1984, TOPL.

[200]  Henri E. Bal The shared data-object model as a paradigm for programming distributed systems , 1989 .

[201]  Zhongxiu Sun,et al.  An object-oriented programming language for developing distributed software , 1987, SIGP.

[202]  Eric C. Cooper Replicated distributed programs , 1985, SOSP '85.

[203]  William B. Ackerman,et al.  Data Flow Languages , 1899, Computer.

[204]  Akinori Yonezawa,et al.  Object-oriented concurrent programming in ABCL/1 , 1986, OOPSLA 1986.

[205]  Seymour Papert,et al.  Mindstorms: Children, Computers, and Powerful Ideas , 1981 .

[206]  Anand R. Tripathi,et al.  Data abstraction mechanisms in SINA/ST , 1988, OOPSLA 1988.

[207]  Nicholas Carriero,et al.  Linda and Friends , 1986, Computer.

[208]  David May OCCAM , 1983, SIGP.

[209]  Graem A. Ringwood Parlog86 and the dining logicians , 1988, CACM.

[210]  Barbara Liskov,et al.  Primitives for distributed computing , 1979, SOSP '79.

[211]  Charles L. Seitz,et al.  The cosmic cube , 1985, CACM.

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

[213]  Anand R. Tripathi,et al.  Data abstraction mechanisms in SINA/ST , 1988, OOPSLA '88.

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

[215]  Nicholas Carriero,et al.  The S/Net's Linda kernel , 1986, TOCS.

[216]  Robert E. Strom,et al.  The NIL distributed systems programming language: a status report , 1984, SIGP.

[217]  Rob Strom A comparison of the object-oriented and process paradigms , 1986, OOPWORK '86.

[218]  Jane W.-S. Liu,et al.  Mentat: An object-oriented macro data flow system , 1987, OOPSLA '87.

[219]  David May,et al.  The Transputer Implementation of Occam , 1984, Fifth Generation Computer Systems.

[220]  Michael Codish,et al.  Compiling OR-parallelism into AND-parallelism , 1986, ICLP.

[221]  J. E. Ball,et al.  Preliminary ZENO language description , 1979, SIGP.

[222]  M. T. Liu,et al.  DISLANG: A Distributed Programming Language/System , 1981, ICDCS.

[223]  Akikazu Takeuchi,et al.  An Object-Oriented Programming Language Based on the Parallel Logic Programming Language KL1 , 1987, ICLP.

[224]  Gruia-Catalin Roman,et al.  A shared dataspace language supporting large-scale concurrency , 1988, [1988] Proceedings. The 8th International Conference on Distributed.

[225]  Shaula Yemini On the suitability of Ada multitasking for expressing parallel algorithms , 1982, AdaTEC '82.

[226]  Richard M. Russell,et al.  The CRAY-1 computer system , 1978, CACM.

[227]  Michael L. Scott,et al.  Design and implementation of a distributed systems language , 1985 .

[228]  M. Elizabeth C. Hull,et al.  Contextually Communicating Sequential Processes — a Software Engineering Environment , 1986, Softw. Pract. Exp..

[229]  Anita Borg,et al.  A message system supporting fault tolerance , 1983, SOSP '83.

[230]  R. C. B. Cooper,et al.  Preserving Abstraction in Concurrent Programming , 1988, IEEE Trans. Software Eng..

[231]  J. G. Hunt,et al.  Messages in typed languages , 1979, SIGP.

[232]  A. S. K. Cheng,et al.  BRAVE - a parallel logic language for artificial intelligence , 1988, Future Gener. Comput. Syst..

[233]  Peter C. J. Graham Using BINS for inter-process communication , 1985, SIGP.

[234]  Laura Ricci,et al.  Static checking of interprocess communication in ECSP , 1984, SIGPLAN '84.