[Pipet Devel] Piper and Narval

[Alexandre Fayolle]

Hi there. 

My name's Alexandre, and I'm working on the Narval project. There are
currently four of us working at full time on Narval, and we should be
releasing Narval-1.0rc1 within a few days.  Martijn Faassen sent us an
email a couple of weeks ago telling us about Piper, and I subscribed to
the Piper mailing list shortly afterwards. However, it seems that I missed
your discussion on Piper and Narval. I wished to clarify a few points.

J.W. Bizzaro seemed to think that Narval was an internet Agent
(http://bioinformatics.org/pipermail/pipet-devel/2000-October/001054.html).
This is not quite true.  Narval _is_ an agent system, but it is not Yet
Another Internet Agent, as Martijn Faassen pointed out in his reply.

Narval is a personal assistant agent, which means that it focuses on
performing tasks. Right now these tasks have to be described manually (by
writing recipes), but we intend to implement planning (that is describing
a goal and letting Narval sort everything out) in a future version.

In order to achieve tasks, Narval executes actions, which can be provided
by some external software, provided a wrapper is written. This wrapper is
made of two parts: an XML prototype which specifies the inputs and outputs
of the action, and a python function which implements the call. The
prototype looks like Piper's loci, though the syntax is different, and the
python function can act as a proxy to some external ressource
(marshalling/unmarshalling of the arguments and doing the actual external
call using whatever protocole is available), or implements the action by
itself.

One of the points you discussed was how the user interacts with Narval.
The answer is 'it depends'. A graphical frontend aimed towards recipe
programming exists, but this is by no way the only way: right now recipes
can listen on network ports (and thus communicate using any standard
protocol such as HTTP) or read emails, and we intend to provide facilities
for voice communication, with a microphone or a voice modem.

There are two main ways of using Narval: the first one is setting it up
with a set of recipes to run as a daemon on a server, and then connect to
Narval when you need it. The second one is launching it on a per need
basis, perhaps write a quick recipe to automate a task and lauch that
recipe. This second way is, AFAIU, closer to what you want to do with
Piper, but we do not put as much emphasis on visualization as you do.

Major differences between Piper and Narval, as far as we've seen, are the
following:

 * Piper seems to put a huge emphasis on distributed objects with corba.
Narval can use corba (and DCOM, etc...), but can do otherwise;

 * the transitions in Narval's recipes can be used to control which part
of the recipes are evaluated, and also give some parallelism and
synchronisation primitives (this is nothing new, it's only Petri nets
semantics);

 * there has been a lot of effort put in Narval so that the kernel would
be able to 'understand' what it is doing, especially when things go wrong
(i.e. when an action fails), so that it can report asynchronously to the
user or take corrective measures alone;

 * XML is used everywhere in Narval, which means that is is very easy to
serialize the state of the kernel and to restore it in some other place
(incidentally, this means that Narval could also be used as a 'knowbot').

Of course this comparison is biased, since I know the Narval project very
well, and only know of Piper what can be understood by reading carefully
the white papers at
http://www.bioinformatics.org/piper/documentation/index.html (which are
getting old), so please bear with me if I misunderstood things about your
project.

I'll be glad to answer any questions you have about Narval and to share
experiences with you, so that we could discuss further what both projects
can bring to one another.

-- 
Alexandre Fayolle
http://www.logilab.com - "Mais où est donc Ornicar ?" - 
LOGILAB, Paris (France).