Skip to content

Tuple-space coordination

Concurrent processes coordinate through shared structured entries selected by associative templates for reading or removal.

Version
v1 · 2026-10-31 · History
Domain-specific #
14593
Domain group
Applied Sciences & Engineering
Origin domain
Computer Science & Software Engineering
Subdomains
Parallel Programming, Distributed Coordination → Computer Science & Software Engineering

Core Idea

Tuple-space coordination lets concurrent processes exchange structured entries through a shared logical space. A producer deposits an entry without naming a receiving process. Another process selects a match by a template and either reads it while leaving it available or removes it.[1][2]

How would you explain it like I'm…

Shared Note Board

Imagine a big shared bulletin board. One kid pins up a note without saying who it's for. Another kid looks for a note that matches what they need and either reads it or takes it down. That way they work together without talking to each other.

Drop-Off and Pick-Up Space

Tuple-space coordination is a way for computer programs running at the same time to work together. There's a shared space where a program can drop off a piece of organized information, a 'tuple,' without saying who it's for. Another program describes the kind of entry it wants, using a pattern, and the space gives it a matching entry to either just read or take away. The programs never have to address each other. The shared space is an idea, so it could live on one computer or be spread over many.

Template-Matched Shared Space

Tuple-space coordination lets concurrent processes communicate through a shared logical space of structured entries called tuples. A process deposits an entry without naming a recipient. Another process supplies a template, a pattern that selects a matching entry, and depending on the operation either reads it (leaving it in place) or removes it. The entry links the processes even if they never address each other directly, which decouples them. This is a coordination rule, not a requirement for a particular setup: the space doesn't have to be one physical memory or one server. Linda describes such a model, and Foster shows tuple-space designs with both central and distributed implementations.

 

Tuple-space coordination is a model in which concurrent processes exchange structured entries (tuples) through a shared logical space. A producing process deposits an entry without naming a recipient. A consuming process supplies a template that selects a matching entry, and depending on the operation either reads it, leaving it in the space, or removes it. The entry mediates the interaction, so processes coordinate without directly addressing one another, decoupling them in identity. The model is a coordination rule rather than a claim about implementation: the space need not be a single physical memory or a single server. Linda presents it as a model with more than one realization, and Foster illustrates a tuple-space module with both centralized and distributed implementation options.

How It Works

The entry, template and selected operation together determine the exchange. Linda's out deposits a tuple, rd reads a match without removing it, and in withdraws a match; a broad template can match more than one tuple without guaranteeing which is chosen.[1] The logical interface can have different implementations, including Foster's central and distributed tuple-space modules.[2]

Examples

Matrix blocks. Carriero and Gelernter describe workers reading coordinate-keyed A and B block tuples with rd, consulting task state and depositing computed C blocks. The input blocks remain reusable. This is an illustrative program, not a measured deployment.[1]

Database search. Foster describes a manager depositing search data, workers removing work tuples and returning scores, and the manager retrieving results before sending stop tuples. The program's objective is to identify the highest score. Suggested genetic-sequence and parameter-simulation domains are possibilities in the book, not observed installations.[2]

Boundaries and Use

This mechanism is more specific than ordinary shared memory or a distributed store because it selects entries by structured content. Tuple-space operations alone do not establish partitioned processing units, co-location, scale-out, middleware or any particular deployment history. JavaSpaces documents a related typed-entry read/take interface; it does not make such wider claims true of every tuple-space system.[3]

Coordination is a broad conceptual neighbor, but no graph parent is established here. The source-described cases show two different workflows within parallel programming: reusable matrix data and consumed search work. They do not imply ordered delivery or automatic scalability and fault tolerance.[1][2][3]

Neighborhood in Abstraction Space

Tuple-space coordination sits in a sparse region of the domain-specific corpus (64th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Storage & Lookup Data Structures (22 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-10-31

References

[1] Nicholas Carriero and David Gelernter, How to Write Parallel Programs: A First Course (MIT Press, 1990), ch. 3. https://lindaspaces.com/book/chap3.html registry ↩a ↩b ↩c ↩d

[2] Ian Foster, Designing and Building Parallel Programs (Addison-Wesley, 1995), §4.5. https://www.mcs.anl.gov/~itf/dbpp/text/node44.html registry ↩a ↩b ↩c ↩d

[3] Qusay H. Mamoud, “Getting Started With JavaSpaces Technology: Beyond Conventional Distributed Programming Paradigms,” Oracle technical article (2005). https://www.oracle.com/technical-resources/articles/javase/javaspaces.html registry ↩a ↩b