Linda can express fine-grained wavefront computations cleanly; future implementations on next-generation machines can support them efficiently.

Entities in the same semantic neighborhood but without a typed relation to this one — candidates for new edges or unrecognized duplicates.

• It is easy to express a wavefront computation in Linda: we use eval to create one process for each element, and rd to read the preceding counter-diagonal.claim0.862
  Illustrates how live data structures are simply expressed.
• Linda achieves scalable performance on distributed-memory machines.claim0.817
  Supported by reported speedup through 64 nodes on iPSC/2.
• The Linda model doesn't care how the multiple execution threads in a Linda program compute what they compute; it deals only with how these execution threads are created and organized into a coherent program.concept0.807
  Foundational principle: Linda's orthogonality to base language and computation model is its core strength.
• Linda is a simpler, more powerful and more elegant model than any of these four alternatives (message-passing, concurrent objects, logic languages, functional).claim0.796
  The central thesis of the paper, stated explicitly in the introduction.
• Linda runs on shared-memory (Encore Multimax, Sequent Balance/Symmetry, Alliant FX/8), distributed-memory (Intel iPSC/2, S/Net), and LAN (Vax/VMS) environments.finding0.793
  Lists the concrete systems on which Linda had been implemented.
• Linda applications show good speedup through 64 nodes on shared-memory and distributed-memory multicomputers.finding0.793
  Empirical evidence of Linda's practical viability across diverse hardware platforms.
• Linda wins the freedom to coexist peacefully with any number of base languages and computing models.concept0.792
  Load-bearing statement on Linda's orthogonal design principle: it doesn't meddle in computation, only coordination.
• Linda is a more practical and a more elegant alternative to concurrent logic programming.claim0.781
  Overall comparison conclusion against concurrent logic.