W3C home > Mailing lists > Public > xml-dist-app@w3.org > March 2000

Re: The Two Way Web

From: Dan Brickley <danbri@w3.org>
Date: Fri, 24 Mar 2000 12:02:13 -0500 (EST)
To: Ken MacLeod <ken@bitsko.slc.ut.us>
cc: xml-dist-app@w3.org, soap@discuss.develop.com
Message-ID: <Pine.LNX.4.20.0003241114050.19183-100000@tux.w3.org>

On 24 Mar 2000, Ken MacLeod wrote:

> Justin Chapweske <justin@cyrus.net> writes:
> > [Mark Baker writes:]
> >
> > > And many (most, from what I've seen) of those real people are
> > > actually *misusing* HTTP.  If it was a simple matter of them
> > > shooting themselves in their own foot, then I wouldn't bother
> > > speaking out.  But encouraging the proliferation of RPC over
> > > the web is the quickest way I can think of to turn a loosely
> > > coupled message-based medium, into a brittle, staticly-bound
> > > one.
> > 
> > Mark, the problem is that most developers feel safe in their warm
> > fuzzy strongly typed, synchronous method call, tightly coupled, RPC
> > world....thats the way they were taught to program.  I think that
> > most people on this list will agree (with some persuasion) that a
> > tightly coupled, development time constructed, web would be a
> > horrible step back.  The problem is one of mapping loosely-coupled
> > message passing ideals onto something that is natural for the
> > mundanes to program against.
> > 
> > Asynchronous message passing used to be this really scary thing
> > until someone had the bright idea to rename them as "Events" and
> > invent a simple programming style for them.  If you want your ideals
> > to stand, an alternative, learnjavain21days, digestable system needs
> > to be developed that is loosely coupled and conceptually simple.
> > 
> > Its all about presentation...
> Agreed.
> I recognized, and quickly came to agreement with, the difference in
> paradigms that Mark presents, but it _is_ a different paradigm that
> has to be recognized first, and we can't expect everyone to grok it
> instantly.  Many of these threads have been arguing at the bits and
> bytes level about completely different paradigms -- _way_ too low
> level for anyone to get a picture of what's being described.
> As far as I can tell, Mark is the most knowledgable person in these
> discussions who understands the paradigm he's presenting.  Mark, we
> need more high-level info before more people can begin to understand.
> Several of the links you've given so far have been either peripheral
> or too deep.

Perhaps this is something of a tangent, but I've been impressed by the way 
some relatively old ideas in this space (Linda systems) have been
re-presented in a simple, more developer friendly manner. I'm thinking of
Sun's Javaspaces/Jini work and the TSpaces system from IBM, though there
are other manifestations around.

I read Mark as coming from roughly the same direction (correct me please
if I'm wrong Mark!). While I personally believe that Web protocol
architectures can (like Javaspaces) might a lot from this tradition, we
can set that topic aside and treat this as a study in technology

A few links (probably not the best selection...) follow:

Some Linda refs: http://www.cs.yale.edu/Linda/linda.html

Jini: 	http://www.sun.com/jini/
      	The End of Protocols, Jim Waldo.

Javaspaces: http://java.sun.com/products/javaspaces/
	(featuring cartoon depiction of the Javaspaces API on front page :-)

	book: http://java.sun.com/docs/books/jini/javaspaces/ 
				with quote from Bill Joy:
			Ever since I first saw David Gelernter's
                             Linda programming language almost
                             twenty years ago, I felt that the basic
                             ideas of Linda could be used to make
                             an important advance in the ease of
                             distributed and parallel programming.

TSpaces: http://www.almaden.ibm.com/cs/TSpaces/
	vision doc: http://www.almaden.ibm.com/cs/TSpaces/html/Vision.html

	[...]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. 

	Overview article: http://www.research.ibm.com/journal/sj/373/wyckoff.html

Jumping back a few years, this is an interesting bridge article:

	[...] Including Linda in W3-based
	applications allows a separation of input/output processing and
	data-processing. This new application structure
	creates the possiblility of W3-based front-ends for stateful transaction
	systems, distributed applications and
	different programming languages. To demonstrate, how easily Linda can be
	included in W3-based applications
	we show code samples in Perl and two example applications which have
	already been inplemented with Linda
	and W3. 

So... I could be taken to be arguing here that the above docs show a
triumph for technology popularisation. I'm not; the newer work feels like
progress, but I've no opinion beyond that.

While I'm not interested in indulging in punditry about the status of
Jini etc, I would like to float a couple of questions:

- do the 'vision thing' articles referenced above help articulate
  the non-tightly-bound paradigm and the connection to our RPC-for-the-Web 
  discussions? (whether this is appropriate technology here is another

- does something _like_ an XML-oriented take on the Linda interfaces
 (ie. a tuplespace model with 'ask' and 'tell' as principle operations) 
  make sense to anyone else here? (This could be eg. a set of XML-RPC
  or SOAP interfaces so we're not talking about a stark opposition 
  between technologies...)


Received on Friday, 24 March 2000 12:02:18 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 22:01:09 UTC