IBM's T-Spaces

Date view Thread view Subject view Author view

From: Rohit Khare (
Date: Fri May 19 2000 - 01:03:16 PDT

TSpaces is a network communication buffer with database capabilities.
It enables communication between applications and devices in a
network of heterogeneous computers and operating systems. TSpaces
provides group communication services, database services, URL-based
file transfer services, and event notification services. Compared to
the systems whose function it emulates, TSpaces is tiny. With its
small footprint, it is ideal for bringing network services to small
and embedded systems; for example, it brings the power of the network
to palm devices, making them fully-fledged network computers.

For the client, being connected to TSpaces is like having the perfect
assistant: TSpaces will remember things for you, it will carry out
any tasks that you assign it, it will report incoming messages and
deliver outgoing messages, and it will notify you of any events in
which you're interested. By adding additional client applications,
TSpaces can be used as a universal print service, email service,
pager service, remote control service, and so on. Since it is written
in Java, T Space client applications can be loaded dynamically into
any network-attached computer. The TSpaces package comes with several
useful applications that show how to build T Space clients.

What is TSpaces?

TSpaces is network middleware for the new age of ubiquitous
computing. A succinct description of TSpaces would be, a network
communication buffer with database capabilities. However, it is often
easier to describe it in terms of what it does. It enables
communication between applications and devices in a network of
heterogeneous computers and operating systems. TSpaces provides group
communication services, database services, URL-based file transfer
services, and event notification services. It is implemented in the
Java programming language and thus it automatically possesses network
ubiquity through platform independence, as well as a standard type
representation for all datatypes.

In more technical terms, TSpaces extends the basic Linda Tuplespace
framework with real data management and the ability to download both
new datatypes and new semantic functionality. The salient features of
the TSpaces system are:

* Tuplespace Operator Superset: TSpaces implements the standard
set of Tuplespace operators: read(tuple), take(tuple), write(tuple).
In addition, it includes both blocking and non-blocking versions of
take and read, set oriented operators such as scan and consuming
scan, and a novel rendezvous operator, rhonda.
* Persistent Data Repository: TSpaces employs a real data
management layer, with functions similar to heavy-weight relational
database systems, to manage its data. T Space operations are
performed in a transactional context, which ensures the integrity of
the data.
* Database Indexing and Query Capability: The TSpaces data
manager indexes all tagged data for highly efficient retrieval. The
expanded query capability provides applications with the tools to
probe the data with detailed queries, while still maintaining a
simple, easy-to-use interface.
* Dynamically Modifiable Behavior: In addition to the expanded
set of built-in operators, TSpaces allows new operators to be defined
dynamically. Applications can define new datatypes and new operators
that are downloaded into the TSpaces server and used immediately.
This is in contrast to relational database systems that have limited
datatype support and limited dynamically defined function (usually in
the form of triggers or, to a lessor extent, user-defined functions).
* Event Notification: Applications can register to be notified
of events as they happen in the TSpaces server.
* Access Controls: Users can establish security policies by
setting user and group permissions on a Tuplespace and operator basis.
* Large Object Support: Applications can specify URLs as field
values. The URL properties can be set as ``copy immediate'' or
``remote reference''. ``Copy Immediate'' implies that the contents of
the URL are copied between the client and server when the tuple is
transferred. ``Remote Reference'' leaves the URL where it is.
However, another operator, ``getURL'' fetches the URL contents for
local processing.

The TSpaces system is appropriate for any application that has
distribution or data storage requirements. It can perform many of the
duties of a relational database system without imposing an overly
restrictive (and primitive) type system, a rigid schema, a clumsy
user interface or a severe runtime memory requirement. In a sense, it
is a database system for the common everyday computing device---one
that doesn't generate complex SQL queries, but one that needs
reliable storage that is network accessible.

Where is it going?

Since TSpaces basically connects all things to all things, there are
many things it is good at. Also, since it is main memory and Java, it
is also ideal to do many things on very small devices, even those
(maybe especially those?) that do not have disk drives. So, sure you
can build a chat room application, a shared whiteboard application, a
distributed cut and paste buffer application, a remote file system
viewer or tons of multi-user games. However, there is ONE MAIN THING
that we think TSpaces will be especially good at. It can (will?) be
the common platform on which we build links to all system and
application services. What do I mean by that? Suppose I want to print
a file on a network printer from a generic client. That's fine if I
have a UNIX client and a UNIX network. It's a little more involved if
the client is Win NT or Win95 and much more involved if the client is
an Apple. However, what if the client is a PDA? At a large site, such
as ours, how do I go about adding all 100 network printers to my
Pilot interface? How do I even add one? Now look at it from the other
side. When I have a private locally attached Win 95 printer (or Mac
printer, etc), how do I access that from a UNIX machine? Sure, there
are specific answers to some of these problems, with regard to
printing, such as running a specialized LP Daemon program that will
talk to UNIX print clients. Now let's cover scanning, faxing, email,
paging, application services (e.g. convert a word document to a
postscript file, invoke a web search on a topic, fetch and parse XML
data) or remote device control (e.g. drive a network attached machine
through an API, access a remote drive).

In the TSpaces world, a common computing environment, with access to
all possible network services, is surprisingly easy to build. A set
of applications, written in Java, map the system-specific service
(e.g. printing service) or application (e.g. web search) to a
standard tuple representation. Then, any client from any platform can
generate a tuple and send it to a TSpaces server. Applications,
listening for specific tuples, pick up jobs when they see them and
execute them. (This is all fairly fast, since it is implemented with
an underlying memory-resident database system.) In building this
environment, one would write the service application to run on the
platforms where they could do the most good. At the IBM Almaden
Research Center, most network printers are visible to AIX systems.
Therefore, one AIX printer service application could listen for
tuples posted to the "printing space", pick them up and send them to
an AIX Queue. Similarly, queries about queues and print status could
also be done. Then, on every other local printer that should be
attached to the common platform, a user simply runs the local print
application (although, in practice, the local application can
probably handle a number of services). Notice, however, that we are
NOT trying to replace any existing tools or services---we are simply
augmenting them with platform independence and flexibility.

One of the really cool things about this environment is that it
injects a smart middleman into the picture. So, as mentioned above,
you can build this nice platform independent print service that gives
you access to any printer in the building. That might be ok, but
perhaps you don't have a clue about where all those printers are.
With a smart middleman, you can add intelligence. When your PDA
includes a location sensor (with no sensor you just have to tell
itwhich room you're in) the smart middleman printer client locates
the non-busy printer nearest you (that still has paper and toner) and
sends the job there -- then shows you a map of how to get there. When
visiting a new location, this sort of service would be incredibly

The number of common network services is limited only by our
imaginations. We're counting on the university population to come up
with some revolutionary ideas. We've thought about cool ways to
incorporate PDAs into the network. If they run Java, then great. If
not, then they will have to communicate some other way, such as using
TCP/IP and sending only primitive types in the message.

There is one more important point to make (or two, depending on how
you count). First, this creates a SINGLE interface for talking to
practically every single service that exists on the network --
everything uses tuples. The exact language that goes inside the
tuples will have to be ironed out over time, of course. Second, while
this all works fine from a command line or GUI interface, tuples can
be sent from programs (from Java programs or from programs that
invoke Java programs). That means that your program can easily send
email, faxes, pages, print jobs, web searches, remote device commands
--- all as easy as sending or receiving a tuple. We've been waiting
ages for smart agents to act on our collective behalf. One of the
things that has slowed down their progress is the interaction to the
outside world (so many different platforms, so many different
interfaces, so little time).

(Editorial note: Last year, a SUN Microsystems speaker confessed that
when SUN came out with the saying, "The Network *IS* the computer"
they really didn't know what they meant. They just figured it would
make sense eventually. Well, now it does.)

The generic diagram that we draw for TSpaces is below. TSpaces, this
database enabled communication buffer, can connect absolutely
everything. With an emerging world of smart, and network connected,
electronic devices, having an existing common platform, like TSpaces,
that they can plug into only makes them more powerful and useful from
the start.
Of course, the ubiquitous computing network is one side of the
picture. Simply being connected to TSpaces itself is convenient, even
if you don't use any network services. For the client, being
connected to TSpaces is like having the perfect assistant: TSpaces
will remember things for you, it will carry out any tasks that you
assign it, it will report incoming messages and deliver outgoing
messages, and it will notify you of any events in which you're
interested. Of course, if you want to use the network services,
TSpaces can be used as a universal print service, email service,
pager service, remote control service, and so on. Since it is written
in Java, T Space client applications can be loaded dynamically into
any network-attached computer. The TSpaces package comes with several
useful applications that show how to build T Space clients. The T
Space server, also written in Java, can be upgraded while it is
running, thus avoiding costly downtime.

MoDAL (Mobile Document Application Language)

MoDAL is a user-interface description language (and a runtime
interpreter) for palm computers with wireless network connection. It
allows users to define a user interface for an arbitrary computer
service. MoDAL provides users with a mechanism for associating user
interface elements with the methods of network services. MoDAL
interconnects with the network of services via TSpaces. TSpaces
enables MoDAL to bring the unlimited computing power to PDAs.


1. Overview
2. System Requirements
3. MoDAL Package
4. Running MoDAL
5. Example Programs
6. MoDAL Grammar
7. Frequently Asked Questions
8. Contributors

1. Overview

MoDAL is being developed as part of the vision of Universal
Information Appliance (UIA). UIA is a concept that will allow a user
with a PDA to control devices and access any information available in
the network by learning the environment in which the PDA is used. A
user of a MoDAL enabled PDA will be able to acquire interfaces for
devices and information agents, which we call services, in the
environment and control them. These services provide defined user
interface elements, being interconnected via TSpaces.

A MoDAL application program presents the user with the client
interface to a specific service. The services available to a MoDAL
user may be programs of any complexity from a simple one which turns
a light on or off to a highly complex applications involving smart
inference on many related events occurring in the system. TSpaces is
the backbone middleware that we are using to make this happen. We
envision a future where the user of a small PDA, rather limited in
its hardware and software capability, is enabled and powered by
TSpaces and MoDAL so that it can take full advantage of ubiquitous
services in the distributed world.

This package includes a MoDAL interpreter, a Java proxy program, and
a set of example MoDAL programs which, running on the Palm Emulator,
talk to services through TSpaces. A user may also write and run
his/her own MoDAL programs using this package. While the version
being distributed in this package is still under development and
implements only a subset of MoDAL, it demonstrates the potential
capability of Modal as a tool for TSpaces's mobile clients.

If you prefer, you can also run MoDAL using a real PDA such as IBM
Workpad and 3Com PalmPilot instead of the emulated environment. There
are two possible configurations that can be used. One is to use a
wireless modem supporting TCP/IP. We used Minstrel wireless modem to
run MoDAL. The other method is to use the cradle to connect IBM
Workpad to the network. This configuration currently works only for
Windows NT. For more information on the use of cradle with Windows
NT, please refer to the web page at

TSpaces Related Efforts

Various Products

There are many potential projects or works that are related to the
TSpaces project because TSpaces can be so many things. TSpaces is a
network communication tool (like the tuplespace systems), it is a
general purpose (though not currently an SQL) database system, and
it's a memory-resident database system (though not one currently
designed for real high performance -- now that would be newsworthy,
wouldn't it -- a high performance database system written in Java).

* Javaspaces: The first one is SUN's Javaspaces, which is very
much like our system in that it's a tuplespace system written in Java.

* Objectspace's Voyager product appears to have some overlap
with TSpaces, although we're still trying to figure out exactly what
they do. More on this as it developments.

* Cloudscape: A SQL database engine written in Java.
Cloudescape intends to market itself as the first Java-based database
system. Where Java goes, so does Cloudscape.

* Sybase's SQL Anywhere: An SQL engine for small devices.
Here's a direct link to the SQL Anywhere page.

* Oracle Lite: Another small SQL engine for small devices.

* TimesTen: A main memory database engine that's zillions of
times faster than any regular SQL engine -- at least that's the rumor.

* Angara: Another main memory database engine -- their
marketing department appears to be less bold than that of TimesTen.

Papers and Projects

Although we're working on a technical report that discusses the
growth of TSpaces -- how it evolved from the early AI Blackboard
systems, Gelernter's Linda Tuplespace, and other follow-on projects
that added Object notions and persistent -- we're not ready to post a
good annotated bibliography here. However, we can post the beginning
of a regular bibliography. There's a whole lot more to go. I've
already promised that I'll get the Jada/Pagespace entries in there.

* [AH96] N. Afshartous and M. C. Harrison, "Expressing
Concurrency in Griffin," IEEE International Conference on Parallel
and Distributed Systems, 1996.
* [ACG86] Sudhir Ahuja, Nicholas Carriero, and David Gelernter,
"Linda and friends," Computer, pp 26-34, August 1986.
* [Ananth 93] R. Ananthanarayanan, Vibby Gottemukkala, Wolfgang
Käfer, Tobin J. Lehman, Hamid Pirahesh, "Using the Co-existence
Approach to Achieve Combined Functionality of Object-Oriented and
Relational Systems," Proceedings of the ACM SIGMOD Conference, pp.
109-118, 1993.
* [AS91] Brian Anderson and Dennis Shasha, "Persistent Linda:
Linda + transactions + query processing," Workshop on Research
Directions in High-Level Parallel Programming Languages, Mont
Saint-Michel, France June 1991. Published as Springer-Verlag Lecture
Notes in Computer Science 574.
* [BG80] Arthur J. Bernstein and David Gelernter, "Storing and
retrieving the network state: a survey and a proposal," SUNY at Stony
Brook Technical Report #80-011, October 1980.
* [BWA94] P. Butcher, A. Wood, M. Atkins, "Global
synchronization in Linda," Concurrency: Practice and Experience
6(6):505-516, 1994.
* [BL94] Ralph M. Butler and Ewing L. Lusk, "Monitors,
Messages, and Clusters: the p4 Parallel Programming System," Journal
of Parallel Computing, April 1994.
* [CD94] S. Cannon and D. Dunn, "Adding fault-tolerant
transaction processing to LINDA," Journal of Software, Practice and
Experience, 24(5):449-466, 1994.
* [Carriero+95] Nicholas Carriero, Eric Freeman, David
Gelernter, David Kaminsky, "Adaptive parallelism and Piranha,"
Computer, 28(1), pp. 40-49, January 1995.
* [CG89] Nicholas Carriero and David Gelernter, "Linda in
context." Communications of the ACM, Vol. 32, No. 4, April 1989.
* [CGH+94] S. Chawathe, H. Garcia-Molina, J. Hammer, K.
Ireland, Y. Papakonstantinou, J. Ullman, J. Widom, "The TSIMMIS
project: integration of hererogeneous information sources",
Proceedings of IPSJ Conference, pp. 7-18, Tokyo, Japan, October 1994.
* [CC+97] B. Christiansen, P. Cappello, M. F. Ionescu, M. O.
Neary, K. E. Schauser, and D. Wu, "Javelin: Internet-Based Parallel
Computing Using Java," ACM Workshop on Java for Science and
Engineering Computation, June 1997
* [CKTV96] P. Ciancarini, A. Knoche, R. Tolksdorf, F. Vitali,
"PageSpace: an architecture to coordinate distributed applications on
the Web," Computer Networks and ISDN Systems, Volume 28, Number 7-11,
May 1996.
* [Cloudscape] "JDBMS and the future of corporate computing",
* [Cor91] Daniel D. Corkill, "Blackboard Systems", AI Expert,
Vol. 6, no. 9, pp40-47, September 1991.
* [DRR+96] A. Douglas, N. R\"{o"jemo, C. Runciman, and A. Wood,
"Astro-Gofer: parallel functional programming with co-ordinating
processes", Euro-Par`96, 1996.
* [DWR95] A. Douglas, A. Wood, A. Rowstron, "Linda
implementation revisited", Transputer and Occam Developments, pages
125--138. IOS Press, 1995.
* [embed]
* [Fra95] Maurice Frank, "Database and the internet", DBMS,
December 1995.
* [GHJ+94] E. Gamma, R. Helm, R. Johnson, and J. Vlissides,
"Design Patterns: Elements of Reusable Object-Oriented Software",
Addison Wesley, 1994.
* [GBD+94] A. Geist, A. Beguelin, J. Dongarra, W. Jiang,R.
Manchek, V. Sunderam, "PVM:Parallel Virtual Machine - A users' guide
and tutorial for networked parallel computing", MIT Press, 1994.
* [GC92] David Gelernter and Nicholas Carriero, "Coordination
languages and their significance", Communications of the ACM, Vol.
35, No. 2, February 1992.
* [Gelernter 85] David Gelernter. "Generative Communication in
Linda." TOPLAS 7(1): 80-112 (1985)
* [Gelernter 82] David Gelernter, Arthur J. Bernstein,
"Distributed Communication via Global Buffer," Proceedings of the ACM
Principles of Distributed Computing Conference, pp. 10-18, 1982.
* [Gelenter 81] David Gelernter, "An integrated microprocessor
network for experiments in distributed programming", SUNY at Stony
Brook Technical Report \#81-024, May 1981.
* [GNS+94] Y. Gutfreund, J. Nicol, R. Sasnett, V. Phuah,
"WWWinda: An Orchestration Service for WWW Browsers and Accessories",
2nd Int. World Wide Web Conference, 1994.
* [HKM+88] J. H. Howard, M. L. Kazar, S. G. Menees, D. A.
Nichols, M. Satyanarayanan, R. N. Sidebotham, M. J. West, "Scale and
Performance in a Distributed File System," ACM Transactions on
Computer Systems, 6(1), February 1988.
* [JavaSpaces]
* [JTS+97] K. Jeong, S. Talla, D. Shasha, P. Wyckoff, "An
approach to fault tolerant parallel processing on intermittently
idle, heterogeneous workstations", Proceedings of The Twenty-Seventh
International Symposium on Fault-Tolerant Computing (FTCS'97), pp.
11-20, IEEE, June 1997.
* [JR89] Keld K. Jensen and Gorm E. Riksted, "Linda, a
Distributed Programming Paradigm", Master's Thesis, Department of
Mathematics \& Computer Science, University of Aalborg, Denmark, June
* [JMW98] I. Jermyn, F. Monrose, P. Wyckoff, "Leaving the
Sandbox: Third Party Validation for Java Applications", Thirteenth
International Conference on Computers and Their Applications, 1998.
* [Kiel95] Thilo Kielmann, "Object-Oriented Distributed
Programming with Objective Linda", Proceeding of the First
International Workshop on High Speed Networks and Open Distributed
Platforms, June 1995.
* [Lehman 86a] Tobin J. Lehman, Michael J. Carey, "Query
Processing in Main Memory Database Management Systems," Proceedings
of the ACM SIGMOD Conference, pp. 239-250, 1986.
* [Lehman 86b] Tobin J. Lehman, Michael J. Carey, "A Study of
Index Structures for Main Memory Database Management Systems,"
Proceedings of the IEEE International Conference on Very Large Data
Bases, pp. 294-303, 1986.
* [Lehman 92] Tobin J. Lehman, Eugene J. Shekita, Luis-Felipe
Cabrera, "An Evaluation of Starburst's Memory Resident Storage
Component," Transactions on Knowledge and Data Engineering, 4(6):
555-566, 1992.
* [ODI]
* [Oracle]
* [MLW 98] Stephen McLaughry, Tobin Lehman, Peter Wyckoff
``Tuplespace: The Next Generation'', Submitted for publication.
* [MAG+97] J. McHugh, S. Abiteboul, R. Goldman, D. Quass, J.
Widom, "Lore: a database management system for semistructured data",
SIGMOD Record, 26(3):54-66, September 1997.
* [Mcl95] Stephen W. McLaughry, "TS++: communication
specification using path expressions in the tuple space programming
model", Bachelor's Thesis, Williams College, June 1995.
* [MediaLab]
* [Nar90] James E. Narem, Jr., "An informal operational
semantics of C-Linda V2.3.5", Technical Report, Yale University
Department of Computer Science, Number TR-839, December 90.
* [NKM+97] Y. Negishi, K. Kawachiya, H. Murata, K. Tago,
"Tuplink: a system structure for mobile micro clients",
* [Polze 93] Andreas Polze. "Using the Object Space: A
Distributed Parallel Make," 4th IEEE Workshop on Future Trends of
Distributed Computing Systems, pp. 234-239(6), Lisbon, September 1993.
* [Reinwald 94] Berthold Reinwald, Stefan Dessloch, Michael J.
Carey, Tobin J. Lehman, Hamid Pirahesh, V. Srinivasan, "Making Real
Data Persistent: Initial Experiences with SMRC," POS 1994: 202-216
* [RW96] Antony Rowstron and Alan Wood, "An efficient
distributed tuple space implementation for networks of workstations",
Euro-Par'96, 1996.
* [Schoen95] W. Schoenfeldinger, "WWW Meets Linda: Linda for
Global WWW-Based Transaction Processing Systems", World Wide Web
Journal, 1995.
* [Sc90] G. Schoinas, "Issues on the Implementation of POSYBL",
Technical Report, University of Crete, 1990.
* [SBA93] B. R. Seyfarth, J. L. Bickham, M. Arumughum, "Glenda
installation and use", distributed with software, November 1993.
* [Tolk93] Robert Tolksdorf, "Laura: A Coordination Language
for Open Distributed Systems", 13th IEEE International Conference on
Distributed Computing Systems ICDCS 93 , pages 39-46, 1993.
* [WMLF98] Peter Wyckoff, Stephen McLaughry, Tobin Lehman,
Daniel Ford, ``TSpaces'', IBM Systems Journal, August 1998.

Date view Thread view Subject view Author view

This archive was generated by hypermail 2b29 : Fri May 19 2000 - 01:07:25 PDT