[Pipet Devel] gui protocol revisited

[Brad Chapman]

> So, once again, this API is XML-based and ran through a socket.  My 
question
> is: Should we use CORBA instead?  What are the 
advantages/disadvantages?  My
> MAJOR interest is that we have multiple UIs that can be attached to 
(and
> controlled by) a single core, can run concurrently in the same 
session, and
> can be controlled by one-another (via the front-request, 
middle-approve
> API). 
> Can we do that with CORBA?
> 
> Thoughts?

I thought that we could keep both the streaming XML dialog *and* 
CORBA, but just in two different places in the program. My idea was 
that we could keep the small middle that we have in Loci right now to 
communiate with the GUI front via the streaming XML dialog you 
describe. 
    This small middle could then also implement the CORBA interfaces 
to pass the information created in the GUI (as a work flow diagram) 
into the "processing" portion of the program. It would make sense to 
pass this as DOM or XML, since it seems like a nice structured way to 
store the data (and since Overflow already uses it to feed its "pull" 
networking system). I think that eventually the processing part could 
move through a work flow diagram in an even "smarter" way (ie. based 
on the fastest way to implement it) which is what Jarl seems to be 
proposing for GMS's with the neural net and genetic algorithms 
processor. Here it seens to makes sense to start with what we have 
(the Overflow pull system) and move into something more robust as 
things move along.
    I think this would make it easier to implement addition front ends 
(since they would only need to deal with XML though a pipe, and not 
implementing a CORBA interface), and will also allow us to re-use the 
code we already have for dealing with communicating with the GUI. In 
addition, I think this will allow us to make a "simpler" CORBA 
interface between the small middle and Overflow and GMS program 
processing functions, since we won't have to worry specifically about 
GUI requirements while coding these.
    Does this make any sense? I think this gives us a lot of reuse of 
code, while maintaing the streaming XML that Jeff digs and the 
CORBA/API interfaces of Overflow and GMS.

Brad