Linda in Context (1989)

The source article that introduces and argues for the Linda parallel programming model, comparing it to message-passing, concurrent objects, logic programming, and functional programming.

Neighborhood — ranked by edge-count

Thinkers (9)

thinker

G. A. Ringwood
mentions
Author of the Parlog86 article in Communications of the ACM used as the main comparison point for concurrent logic programming.
C. A. R. Hoare
mentions
Inventor of monitors and Communicating Sequential Processes (CSP).
Gul Agha
mentions
Author of a comprehensive book on the Actors model.
Ken Musgrave
mentions
Researcher in Mandelbrot's group deploying Linda for ray-tracing fractal image generation.
Marina C. Chen
mentions
Creator of the Crystal parallel functional language, used as comparator for functional programming.
Paul Bercovitz
mentions
Built the tuple space visualization tool at Yale; acknowledged in the paper.
Jerrold Leichter
mentions
Senior member of the Yale Linda group; co-author of distributed-data-structure and network performance paper.
Robert Bjornson
mentions
Senior member of the Yale Linda group.
Venkatesh Krishnaswamy
mentions
Senior member of the Yale Linda group; co-author of Linda coprocessor paper.

Frameworks (6)

framework

Concurrent Object-Oriented Programming
cites
A major competing approach to parallel programming based on instantiating objects with embedded active processes and monitors for synchronization.
Actors Model
cites
A message-passing concurrency model where processes (actors) communicate via messages (talks) and generate new processes; related to concurrent objects.
Crystal
cites
Pure functional language with compiler-directed parallelism; Linda authors compare it on DNA sequence similarity computation.
C-Linda
introduces
The C language embedding of Linda operations.
Concurrent Prolog
cites
An early concurrent logic programming language.
Monitor model (Hoare)
cites
Concurrency control using monitors with condition queues; compared to Linda's tuple space.

Methods (1)

method

interpretive abstraction (method)
introduces
Programming technique to restructure a fine-grained Linda program for efficiency by replacing live data structures with passive ones and coarser-grain processes.

Claims (17)

claim

Linda is a simpler, more powerful and more elegant model than any of these four alternatives (message-passing, concurrent objects, logic languages, functional).
about
The central thesis of the paper, stated explicitly in the introduction.
The unification of process and data creation means that we can organize collections of processes into 'live data structures'.
about
Explains a key consequence of generative communication.
When a problem has a simple solution, a useful system will give programmers access to the simple solution; Parlog forces complex solutions to simple problems.
about
Critique that Parlog's abstraction level is too high and restrictive.
The Linda code is insensitive to the number of clients, whereas Parlog requires a merge process that depends on the count.
about
Demonstrates flexibility advantage.
Concurrent object oriented programming has little or no meaning; it strikes us as more of a marketing than a technical term.
about
Strong assertion that OOP does not inherently address parallelism.
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.
about
Illustrates how live data structures are simply expressed.
Pure functional languages cannot be the whole story for parallel programming because they fail to provide needed expressivity.
about
Argument that recursion equations are inappropriate for many important parallel programs.
The fact that senders in Linda needn't know anything about receivers and vice versa is central to the language.
about
Claims the uncoupled style is a key advantage.
C-Linda code is easier to understand than the Parlog86 version [for the client-server problem].
about
Subjective but argued comparison.
Communication and process creation are two facets of the same operation in Linda.
about
Linda unifies process creation and communication through generative communication.
Interpretive abstraction is a fairly simple programming technique, but it's only possible if the parallelism tools are under the programmer's control.
about
Contrasts with auto-parallelizing compilers; flexibility of Linda.
It is impossible for us to accept the claim that functional languages are necessarily higher-level than C-Linda.
about
Critique of the functional-level argument based on mental models.
Monitors are not as flexible as tuples for building distributed data structures.
about
Comparison arguing that monitors restrict concurrent access and complicate distributed structures.
Parallel programming needn't be terribly difficult, but 'thinking in simultaneities' as in message-passing is calculated to make it difficult.
about
Asserts that Linda's uncoupled style reduces cognitive load.
The Linda model-a swarm of active tuples surrounded by a cloud of passive ones-is suggestive in itself.
about
Comment on the conceptual elegance of the model, used in conclusion.
The strengths of all three models (concurrent OOP, logic, functional) are irrelevant to parallelism, and generally unhelpful in dealing with process creation and coordination.
about
Assertion that the popular models add nothing to parallel programming.
The tuple space model covers all forms of communication: inter-process, inter-language, user-system, past-future.
about
Argues the generality of the model beyond just parallel programming.

Concepts (9)

concept

Linda (tuple space model)
introduces
A model of process creation and coordination based on generative communication and tuple spaces; the central topic of the paper.
Nicholas Carriero
authored
Co-author introducing Linda, a parallel programming model based on tuple spaces.
Parlog86
cites
Concurrent logic language; Linda authors demonstrate simpler solutions to client-server and dining philosophers problems.
David Gelernter
authored
Co-author introducing Linda, a parallel programming model based on tuple spaces.
Live Data Structures
introduces
A structuring technique where each element of a result is computed by a separate process that turns into a data element; enables fine-grained parallelism.
Emerald
cites
State-of-the-art concurrent object system using monitors; Linda authors compare and critique its synchronous RPC-based communication.
Uncoupled Programming Style
introduces
A programming paradigm where senders and receivers in Linda need not know anything about each other, reducing coupling in parallel programs.
distributed data structures
introduces
Data structures stored as collections of tuples in tuple space, accessible to many processes.
Message-Passing Model
cites
Traditional parallel programming model where processes send directed messages to each other; contrasted with Linda's generative communication.

Artifacts (3)

artifact

tuple space visualizer
about
Debugging tool that displays tuple space state as quasi-physical spheres, built by Paul Bercovitz.
Linda Machine
mentions
Hardware prototype that supports tuple space operations directly.
Linda system (Yale implementation)
mentions
The actual Linda implementation from the Yale group, including C and Fortran versions, running on various parallel machines.

Questions (1)

question

How can a system that differs sharply from all currently fashionable approaches score any kind of success?
about
Opening question setting up the paper's purpose.

Communities (1)

community

Generative Communication
introduces