Re: 9X Distributed Annex? CORBA?

[abg@sei.cmu.edu (Anthony Gargaro)]

In article <WOODRUFF.94Sep30130332@ec2226.addvax.llnl.gov>, WOODRUFF@ec2226.addvax.llnl.gov writes:
|> 

|> I have studied the RM's Distributed Annex, and I recognize that the
|> language standard will allow me to build the system I need.  However I
|> am not aware of any implementation of the Annex. I have not seen any
|> claim by the GNAT team that they are planning an Annex implementation.
|> Validation of commercial compilers is likely to be higher priority to
|> compiler businesses than building Annexes.  Therefore my first question
|> is "where and when am I likely to obtain an implementation of
|> Distributed Annex?"

A non-government academic/industrial initiative is ongoing to build an open
systems prototype of the Distributed Systems Annex. Initially this will be
implemented for the GNAT (with the cooperation of the NYU team for the core
language support). The intent is to make this prototype available coincident
with the currently planned final release of GNAT (ca 3Q'95). (The attentive
listener to Dr. Reifer's briefing at the WAdaS this year would have heard this
initiative mentioned.)

|> The other standard that appears relevant to my intention is CORBA.  I'm
|> pretty uninformed about implementations of CORBA, so I'd welcome advice
|> about what I should do to prepare for eventual use of these products.
|> How will Ada interface to CORBA tools? Will CORBA implementations let me
|> mix my application parts with components in other languages, or even
|> with COTS software?  

Both CORBA and the Distributed Systems Annex support what is becoming
popularly called "distributed objects" (or "network objects") by the
distributed programming literati. One significant difference is that CORBA is
language independent and requires that the CORBA Interface Definition Language
(IDL) be mapped to the implementation language of each object.  Consequently,
the CORBA concept is to provide, through distributed objects, the seamless
integration of multilingual heterogeneous distributed applications. (Note the
current specifications do not detail the necessary interoperability to achieve
this concept.)

|> What is the relationship of CORBA to the distributed annex?  If the two
|> are complementary strategies, then what will I need to buy and what do I
|> need to learn so I can plan my application?  On the other hand if they
|> are two competing paradigms, how can I choose between them, and how bad
|> will be my punishment if I choose the wrong one?

The two paradigms are very similar from an applications programmer's
perspective. They may be viewed as complementary, providing a continuum of
distributed programming capabilities. For an Ada 9X distributed application,
where predictability and safety is more important than integrating a
collection of cooperating heterogeneous components, the annex may be
preferable. If this application has to be interconnected within the context of
a larger CORBA-compliant application, then one partition of the Ada 9X
application can be implemented as the application gateway. This gateway would
use both the annex and the IDL mapping to Ada 9X; the other partitions would
remain unchanged.

Tucker has noted several ways in which the respective implementations may
potentially coexist. For example, the PCS may be implemented using the ORB
core facilities; this would allow IDL requests for an object's service to be
routed to an Ada 9X implementation of a conforming distributed object.

Note that there is an effort to fast track the CORBA/IDL as an ISO
standard. Regardless of whether or not this is appropriate (given the
linguistic lineage of the IDL), an IDL mapping to Ada 9X becomes increasingly
critical to Ada 9X.