[Pipet Devel] thoughts on UI->DL communication

[J.W. Bizzaro]

Brad, Jarl and I were all talking about UI->DL communication over chat.  I
want to summarize my own thoughts.

First, the VSH plan for the UI->DL parts and the communication between them,
is to re-use Loci's Front->Middle parts and communication.  So,

     VSH            Loci
    ------         ------
    UI->DL  ==  Front->Middle

But Loci's Front->Middle parts and communication are also very similar in
design to VSH's DL->BL parts and communication.  Both Front->Middle and
DL->BL...

    * Act like client->server
    * Pass XML
    * Need authentication to connect
    * Can connect across a network

So, I see a lot of duplication between UI->DL and DL->BL in the current plan
that need not be there.

Jarl suggested that VSH use 1 UI per DL.  This makes DL a client rather than a
server and eliminates much of the duplication mentioned above.

But I wonder, if there is only 1 UI per DL, why do they need to be separate? 
Could they both be in Python?  I think there are several advantages:

    (1) Speed: Direct Python communication rather than socket
    (2) Less processes running: 1 processes rather than 2
    (3) Unified code base
    (4) One less authentication system needed (recall we would need 3)
    (5) Elimination of sockets: keep corba as the only protocol
    (6) No XML management (reading and writing) between the two

I would propose that both the UI and the DL be combined into one Python code
base, and have the UI (in particular, the Gnome UI) be a module library for
the DL to import.  This UI library would have a well defined API with events,
etc.

But Brad pointed out that there would be (at least) 2 problems:

    (1) There would be a lot of rewriting to do, which would make Brad
        very unhappy.

I'm not suggesting that we re-integrate the two parts.  I think the separation
is good, because the use of the UI as a library would require a separate
anyway.  And as far as work goes, I can do it myself.

    (2) Other UI's would have to be made in Python.

Actually, there are 2 ways we can make UI's in other languages:

    (a) The whole UI->DL part can be written in another language
        and use CORBA to communicate with the BL.

    (b) Write a UI part in Python that can communicate with non-Python
        UI's, using a language-neutral protocol like CORBA.

My argument for doing it now is this: IT WILL BE A LOT HARDER LATER ON WHEN
THE UI->DL PROTOCOL BECOMES BETTER DEVELOPED!

Comments?

Cheers.
Jeff
-- 
                      +----------------------------------+
                      |           J.W. Bizzaro           |
                      |                                  |
                      | http://bioinformatics.org/~jeff/ |
                      |                                  |
                      |        BIOINFORMATICS.ORG        |
                      |           The Open Lab           |
                      |                                  |
                      |    http://bioinformatics.org/    |
                      +----------------------------------+