coordination language 

Yale. A "coordination language", providing a model for concurrency with communication via a shared tuple space. Usually implemented as a subroutine library for a specific base language.

explores a variety of research topics in parallel and distributed programming languages, groupware and information systems. Much of the work centers around the Linda programming language or ideas that have been spawned from work on the Linda system. The Linda Group, Dept. of Computer Science, Yale University.

(See C-Linda, Ease, Fortran-Linda, Glenda, LindaLISP, Lucinda, Melinda, Prolog-Linda).

Related languages
Linda => C++Linda   Implementation
Linda => C-Linda   Implementation
Linda => Ease   Implementation
Linda => ELLIS   Implementation of
Linda => ESP   Incorporated some features of
Linda => Fortran-Linda   Implementation
Linda => Glenda   Implementation
Linda => ISETL-Linda   Implementation
Linda => Klaim   Extension of
Linda => Law-Governed Linda   Enhancement of
Linda => LindaLISP   Implementation
Linda => Lucinda   Implementation
Linda => Melinda   Augmentation of
Linda => Opus   Incorporated some features of
Linda => Orca   Influence
Linda => Pascal-Linda   Incorporated some features of
Linda => Prolog-D-Linda   Implementation
Linda => Prolog-Linda   Adaptation of
Linda => Prolog-Linda   Implementation
Linda => Scheme-Linda   Implementation
Linda => Shared Prolog   Implementation
Linda => WWWinda   Implementation

  • Gelernter, D. "Generative Communication in Linda" view details
          in TOPLAS 7(1) January 1985 view details
  • Carreiro N. et al, "Linda in Context" view details
          in [ACM] CACM 32(04) (Apr 1989) view details
  • Nicholas Carriero and David Gelernter. "How to Write Parallel Programs: A Guide to the Perplexed" view details
          in [ACM] ACM Computing Surveys. November, 1989. view details
  • Miller PL, Nadkarni P, Gelernter JE, Carriero N, Pakstis AJ, Kidd KK "Parallelizing genetic linkage analysis: a case study for applying parallel computation in molecular biology" Comput Biomed Res. 1991 Jun;24(3):234-48 view details Abstract: Parallel computers offer a solution to improve the lengthy computation time of many conventional, sequential programs used in molecular biology. On a parallel computer, different pieces of the computation are performed simultaneously on different processors. LINKMAP is a sequential program widely used by scientists to perform genetic linkage analysis. We have converted LINKMAP to run on a parallel computer, using the machine-independent parallel programming language, Linda. Using the parallelization of LINKMAP as a case study, the paper outlines an approach to converting existing highly iterative programs to a parallel form. The paper describes the steps involved in converting the sequential program to a parallel program. It presents performance benchmarks comparing the sequential version of LINKMAP with the parallel version running on different parallel machines. The paper also discusses alternative approaches to the problem of "load balancing," making sure the computational load is shared as evenly as possible among the available processors.

          in [ACM] ACM Computing Surveys. November, 1989. view details
  • Miller PL, Nadkarni PM, Carriero NM "Parallel computation and FASTA: confronting the problem of parallel database search for a fast sequence comparison algorithm" Comput Appl Biosci. 1991 Jan;7(1):71-8 view details Abstract: We have parallelized the FASTA algorithm for biological sequence comparison using Linda, a machine-independent parallel programming language. The resulting parallel program runs on a variety of different parallel machines. A straight-forward parallelization strategy works well if the amount of computation to be done is relatively large. When the amount of computation is reduced, however, disk I/O becomes a bottleneck which may prevent additional speed-up as the number of processors is increased. The paper describes the parallelization of FASTA, and uses FASTA to illustrate the I/O bottleneck problem that may arise when performing parallel database search with a fast sequence comparison algorithm. The paper also describes several program design strategies that can help with this problem. The paper discusses how this bottleneck is an example of a general problem that may occur when parallelizing, or otherwise speeding up, a time-consuming computation.

          in [ACM] ACM Computing Surveys. November, 1989. view details
  • Nadkarni PM, Miller PL. "Parallel computation for biological sequence comparison: comparing a portable model to the native model for the Intel Hypercube" pp404-8 view details Abstract: A parallel program for inter-database sequence comparison was developed on the Intel Hypercube using two models of parallel programming. One version was built using machine-specific Hypercube parallel programming commands. The other version was built using Linda, a machine-independent parallel programming language. The two versions of the program provide a case study comparing these two approaches to parallelization in an important biological application area. Benchmark tests with both programs gave comparable results with a small number of processors. As the number of processors was increased, the Linda version was somewhat less efficient. The Linda version was also run without change on Network Linda, a virtual parallel machine running on a network of desktop workstations.
          in Proc Annu Symp Comput Appl Med Care. 1991 view details
  • Shifman MA, Windemuth A, Schulten K, Miller PL "Molecular dynamics simulation on a network of workstations using a machine-independent parallel programming language" pp414-8 view details Abstract: Molecular dynamics simulations investigate local and global motion in molecules. Several parallel computing approaches have been taken to attack the most computationally expensive phase of molecular simulations, the evaluation of long range interactions. This paper develops a straightforward but effective algorithm for molecular dynamics simulations using the machine-independent parallel programming language, Linda. The algorithm was run both on a shared memory parallel computer and on a network of high performance Unix workstations. Performance benchmarks were performed on both systems using two proteins. This algorithm offers a portable cost-effective alternative for molecular dynamics simulations. In view of the increasing numbers of networked workstations, this approach could help make molecular dynamics simulations more easily accessible to the research community.
          in Proc Annu Symp Comput Appl Med Care. 1991 view details
  • Skillicorn, David B. and Talia, Domenico "Models and languages for parallel computation" pp123-169 view details
          in [ACM] ACM Computing Surveys (CSUR) 30(2) June 1998 view details
    • Linda home page
      external link
    • Linda Reports at Yale
      external link
    • Sara Linda Page
      Linda-or more precisely, the Linda model- is a general model of parallel computing based on distributed data structures (although ... it may be used to implement message passing as well). Linda calls the shared data space "tuple space". C-Linda is an implentation of the Linda model using the C programming language, and Fortran-Linda is an implementation of the Linda model using the Fortran programming language. Processes access tuple space via a small number of operations that C-Linda and Fortran-Linda provide. For example, parallel programs C-Linda are written in C and incorporate these operations as necessary to access tuple space. In this way, C-Linda functions as a coordination language, providing the tools and environment necessary to combine distinct processes into a complete parallel program. The parallel operations in C-Linda are orthogonal to C, providing complementary capabilities necessary to parallel programs. C-Linda programs make full use of standard C for computation and other non-parallel tasks; C-Linda enables these sequential operations to be divided among the available processors. Since C-Linda is implemented as a precompiler, C-Linda programs are essentially independent of the particular (native) C-compiler used for final compilation and linking. Fortran Linda operates in an analogous mannerexternal link