Building User Interfaces for CORBA Objects with Java

Paper: 363
Session: E (talk)
Speaker: Ogg, Michael, University of Texas, Austin
Keywords: CORBA, object-oriented methods, GUI's, Internet PC's, Java

Title: Building User Interfaces for CORBA Objects with Java

Authors: Michael Ogg, Fabio Previato, Arun Swaminathan, Gregory Sharp

Affiliation: University of Texas at Austin
Cornell University

Collaboration: Nile/CLEO

The Nile system has a distributed architecture of CORBA objects (as
described in other submitted papers). So as not to break the CORBA model,
all external interfaces, including client GUIs, should have a consistent
CORBA IDL description. The GUI is used to submit a job and query its status.
But the SiteManager (the main interface between Nile and all other clients)
must be able to call the client back, both in the case of normal or abnormal
events, as well as to present intermediate results (e.g. continuously update
histograms). Further, although the main farm(s) of computers that actually
do job processing is a specialized environment, there is every reason to
allow the maximum flexibility, and choice of platform, for the client.

The Java language is a natural client language, because (as well as being
Object-Oriented) it has the following properties:

1. natural network-based programming constructs,
2. simple and relatively capable (although not as powerful as e.g. Xlib)
graphics constructs,
3. extensibility with class libraries,
4. platform independence by way of interpreted byte code,
5. straightforward call back via built-in threads
6. support for CORBA using the Internet Inter-ORB Protocol (IIOP), as
specified by the CORBA v2.0 standard.For the needs of a client, the relatively slow performance (because it is
interpreted) is not a major drawback. Besides, the emergence of "Just in
Time" and native compilers, together with the growing development of Java
chips, and "network appliances" will ensure that Java performance will not
be a limitation.

A more significant programming difficulty (which will be covered in this
talk) is making Java clients communicate via a CORBA interface. The CORBA
standard specifies the IIOP as the means for different vendors' ORBs to
interoperate. We present results and experience gained from making this work
in practice. We have been using C++ ORBs from Iona and Visigenic, as well as
Electra (which is the ORB used in Nile), and Java ORBs from Iona and