Break on Through to the Other Side

-- 1999 HPTS Position Paper --
Tobin J. Lehman
IBM Almaden Research Center
650 Harry Road (K55/801), San Jose, CA-95120

April 1, 1999

Introduction: Old Habits Die Hard

The 1990's gave us the web: an unstructured universe of information. Businesses and technology-savvy people embraced it, flooding the internet with information about their products, their services, their humorous life stories and pictures of their kids and dogs. Web servers proliferated, serving up static pages at first, then more complicated dynamic pages as users' demands increased. HTML was popularized as a simple (though content-agnostic) language for producing web pages. Search engines (e.g. Hotbot) and taxonomy pages (e.g. Yahoo) thrived, as users of the web tried to find useful information in this huge sea of data.

In general, web-users and e-consumers were excited, as they could do much more with the web than they had ever been able to do before. They could not only locate more data on any topic, but they could also participate by publishing their own stuff. However, they were also vexed by the web's limitations. The difficulty of navigating this seemingly infinite sea of data to locate a specific item often produced a sad tale of confusion, frustration and chaos. Also, though it was a useful source of information, the web didn't solve many of the existing problems of computers. The web was yet another entity, separate from the other computing resources: data storage, electronic devices, network services, personal applications and enterprise applications. It didn't help with connecting your computer to the printer in the next office, or changing your home security program from your mobile PDA.

Everything Looks Like a Nail

We've often seen cases of pushing a solution too far (when all you have is a hammer, everything looks like a nail). Such was the case with the web -- since it was the cool thing that could be used for many things, it often got bent into numerous weird shapes and positions (many that were not natural), in an attempt to make it do just about everything. However, there are some things it just can't do. For example, the web, as designed today, is simply not meant to incorporate pure peer to peer interaction between entities, resources and services. It is a simple, one-sided (pull-oriented), client-server model -- clients issue queries of servers and receive answers.

Besides the inherent limitations of the web's client-server model, there have been several other factors that have limited its usefulness. The web was decentralized (a good thing), but it was also anarchistic (a bad thing). With no official repositories for registering content, representation or interchange formats, there was no way to maintain any consistent structure. As a result, with no schema for the web, most web search results contain 95-99% garbage.

Another limitation of web servers was their lack of flexibility in serving up content. Web servers mostly supplied static files (in the form of html or images) in response to browser requests, though they could do more. They were capable of executing some script (e.g. cgi-bin, servlets) that performed some computation (e.g. database query, application access) to serve up dynamic content, but these scripts were specific to the particular application. Thus, to offer a new function in a web server meant that someone had to create a new server side script. If a web administrator wanted to give users the ability to connect to the car database, she had to write a script for that. If she wanted users to control devices from a web page, she had to write a script for that. This was not a general purpose solution.

e-Space: A New Hope

If we were to start all over in making a real electronic community, what would we build? Also, knowing what we know now, what would we do the same (as when we built the web) and what would we do differently? Well, first of all, this electronic space (we'll call it "e-Space"), would contain everything. All entities (people, devices, businesses, etc) and all resources (information, services, applications, etc) would belong; nothing would be left out. We would design it so that all entities and resources could interact in interesting ensembles to do productive work. Secondly, since a big part of e-Space is information, we would try to keep the good things about the web and fix the bad things when we created the global information resource.

With the above-mentioned points as our general plan, how do we go about creating the specific components to achieve our vision? We have to answer a set of questions.

  1. How do we discover all of the entities and resources?
  2. How do we register everything in a decentralized entity/resource directory?
  3. How do we physically connect all things together (using both wired and wireless systems)?
  4. How do we coordinate ensembles of components to cooperate on specific tasks?
  5. How do we solve the information exchange problem -- the differences in schemas, data format, and communication protocols?
At the IBM Almaden Research Center, we are building many of the components that address the above questions.

A central piece of this project is the TSpaces ( ) server, a distributed middleware component that has database function (queries, rules, persistence), ACID transactions, replication, event notification, file management, proxy services, and built-in XML support. It uses the tuplespace model of communication, which allows for asynchronous and anonymous coordination between clients. Also, not being a relational database system, TSpaces is instead a semi-schema-less database system that allows much more flexible record storage and type support (any type of Java object can be stored in TSpaces).

Another piece of the project that shows off the flexibility of the TSpaces server is the MoDAL (Mobile Document Application Language) client engine. MoDAL is what turns a regular wearable computer (with wireless communication) into a fully functional Universal Information Appliance (UIA). The MoDAL engine is a client-side interpreter that renders User Interfaces, performs local client-side database operations, performs client-side scripting operations and activates resources and talks to entities in e-Space through TSpaces communication. A simple example of MoDAL function would be an administrator control panel that would allow a system administrator, working remotely, to push MoDAL UI buttons to monitor system activity, enter into chat sessions with other users, push buttons to activate hardware devices (lights, fans, robots, etc) or enter text in a MoDAL forms panel to conduct information searches.

The Network is the computer and e-Space is the application

Some have said that the network is the computer. That's fine, but what is a computer without an application? If you think of the entire network as a computer, then e-Space is the application that runs on it -- everywhere, on everything. The UIA (universal information appliance -- a PDA running the MoDAL client) is your remote control panel, through which you can communicate with anyone, control any device or interact with any service.

Keep It Simple (Stupid)

The power of this model is immense. Loosely connected system components interact through the TSpaces distributed system (as well as through data transmogrifying proxies) to work together in ensembles of ad hoc cooperating entities. All entities and resources are locatable through the global distributed resource directory. The schemas of everyone's data are expressed in XML and can be discovered through the resource directory.

An outside observer of e-Space might be frightened by the apparent complexity of millions of entities and resources working together in ad hoc ensembles. However, from the view of any one entity or resource is pure simplicity -- you publish what you got, you register which schema you use, you listen for others that wish to interact with you.

Active Environments

The applications of e-Space are as much fun to dream up as they are to use. Active environments is one such example. In e-Space, there are sensors and other triggered inputs that furnish data to anyone interested. By just registering an interest in the sensor events, and attaching them to a "electronic assistant" application, you can create your own active environment where simply being in a particular location can trigger events beneficial to you (be told the history of the street corner you're standing on, open a door, notify the airport that you've arrived at the gate, etc).

Where's the Transaction Processing?

In e-Space, where are the heavy duty transaction systems of yester-year? Well, they're still there. We're not going to replace them, we'll just augment them with a better front end that makes them more friendly to the rest of the electronic community. But, in addition to the old-style transaction systems, there's a new style of interaction that requires varying amounts of the old rules for consistency and isolation. Just like web servers today often sacrifice data integrity (2 phase locks) for speed, so will the transaction managers in e-Space tailor their requirements to the particular needs of the ensemble.

We believe that e-Space is a breakthrough concept that will allow incredibly complex systems to be build using extremely simple technology. The old skills of distributed transaction management still apply, but the interfaces between different components will be formally defined and mapped by proxies to hook up disparate systems that would have previously been incompatible. This is a picture of the future, and it's a rosy one indeed.