[kepler-dev] seek/kepler conference call notes

[Shawn Bowers]

Matt Jones wrote:

> 2) Some of our actors have a set of ports that are defined and loaded at 
> design time rather than compile time, and are determined by an external 
> source.  For example, the EMLDataSource actor gets its port definitions 
> by reading the metadata about a data source, and the WebService actor 
> gets its port definitions by reading the WSDL document for the service. 
> I had thought that having external annotations would be good because 
> they could be associated with the WSDL or EML rather than the actor 
> itself.  We'll need a way to annotate these dynamically created ports as 
> well as those that are statically defined within an actor.  I envision 
> this to be common.  Another example is instantiating a hypothetical R 
> actor with the ports needed for data flow into and out of a specific R 
> script, rather than using the CommandLine as we currently do (which 
> bypasses all of our typing mechanisms).

These actors that configure themselves based on some other information 
seem to be tricks to make (1) the user interface uniform and (2) to 
avoid writing user interface code.  (This isn't meant to be a negative 
comment about these types of actors, just an observation, and in fact it 
probably makes sense to do it this way rather than to have separate user 
interfaces for each such generic component.) In and of themselves, they 
are not "real" actors because they haven't been "instantiated" or 
"implemented" until they are configured. That is, to actually use them 
in a workflow they have to be realized (they are acting as shells, or 
abstract classes without implementations).  Once one of these actors has 
been configured, they conceptually generate a new, "concrete" actor.

So what about this idea: Force annotation through Ptolemy, so we don't 
have to figure out how to annotate multiple languages (EML, WSDL, XML, 
etc., etc.). And the only thing that could be annotated would be actors 
and models (workflows). Similar to what Edward mentions, you might have 
a context menu entry for actors called "annotate" which would bring up 
the annotator tool. So, if I configure the WebService actor with an 
actual web service WSDL, then I should not only be able to name and save 
the new actor (which can currently be done), but also annotate it just 
like any other actor. The same should be true of the EML actor, and any 
of the expression language ones. For EML, the actor is representing the 
corresponding dataset.

An interesting problem/question with these generic actors is whether it 
is useful to determine if there already exists a concrete version that 
has been annotated, after configuration. Lets say I used the generic 
WebService actor to create a concrete actor for WebService ABC. I also 
went to the trouble of saving it and annotating it. Now, someone else 
creates a new workflow and wants to use the ABC WebService, but doesn't 
realize I went to the trouble to already construct and annotate it. It 
would be really great if as they "instantiated" ABC with the WebService 
actor, it could inform them that one already exists.  This probably gets 
a little tricky ;) for the expression languages, but for EML and for 
WSDL, I think it makes sense.

Shawn