W3C home > Mailing lists > Public > www-ws@w3.org > September 2003

RE: Process instantiation puzzle

From: Matthew Fuchs <Matthew.Fuchs@westbridgetech.com>
Date: Fri, 19 Sep 2003 14:50:46 -0500
Message-ID: <E067E85727FC0B47BC593D5AA1F7C3B9770FD8@MAIL-06VS.atlarge.net>
To: "Drew McDermott" <drew.mcdermott@yale.edu>, <www-ws@w3.org>


Isn't this a bisumulation question? Or is it just underspecified? :-)

In other words, if you can't tell the difference, then what difference
does it make?

Of course, one way to tell the difference is to pull out your network
cable between the first two invocations, in which case there would not
be a bisimulation between the single cpu, multiple cpu versions - their
behaviors can be distinguished.

It's all well and good to pretend that the two are the same, and it
certainly makes programming easier, but a lofty "don't care" won't hold
out of the academic community, or to paraphrase a friend of mine who
used to build trading systems, it's a real wakeup call when an irate
trader calls you in the middle of the night and screams that your
software lost him $200MM.

But spending too much time caring probably makes services very onerous
to write.  My guess is that many of these aspects of a service will be
set in the environment and not need to be part of the algorithm

Matthew Fuchs

-----Original Message-----
From: Drew McDermott [mailto:drew.mcdermott@yale.edu] 
Sent: Thursday, September 18, 2003 11:40 AM
To: www-ws@w3.org
Subject: Process instantiation puzzle

There's a theory of processes in DAML-S that has a lot of support;
I'll call it the Majority Position because it seems to be, modulo
various reservations.

The theory goes like this: processes have inputs and outputs.  Where
these come from and where they go is not part of the definition of the
process.  In particular, if a composite process C contains an
invocation of process P, there's no way to know just by looking at the
definition of C whether P is to be executed by the same interpreter
(or "enactor") as the one executing C.

Puzzle: Suppose C sends a message to P two or more times, at least on
some runs, e.g.:

   C = (seq (P) (if Q then ... else (P)))

I've suppressed the actual dataflow, but assume that C is sending data
to P and getting some back.  With respect to a run of C in which Q is
false after C interacts with (P), let P1 be that first interaction,
and P2 be the second.

What exactly are P1 and P2?  Is each a fresh invocation of the P
process?  Is there a worldwide P process that everyone communicates
with (e.g., an atomic clock sitting in Geneva).  Or does the
invocation P1 create an entity that C talks to when P2 occurs?  How
are these different possibilities to be indicated?

If P is just a subroutine, the answers are clear.  P1 and P2 are
independent invocations that create fresh processes each time.  How
does an espouser of the Majority Position answer?

                                             -- Drew McDermott
                                                Yale University CS Dept.
Received on Friday, 19 September 2003 15:50:43 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 23:05:12 UTC