Distributed Systems Development - Autonomics Development: A Domain-Specific Aspect Language Approach - page 25

• DateHolder.java . This class holds a public instance member of type Date
and is used for all operations that have an inout IDL declaration.
• Operations.java . This interface contains the methods getDate() and
shutdown() and is shared by both the stubs and skeletons.

2.4.3 CORBA Example Implementation

Our server implementation is illustrated in Figure 2.9 and our client implementa-
tion in Figure 2.10. As can be seen by these examples, Java's CORBA framework
is highly intrusive in nature, requiring the developer to implement the framework's
code alongside the applications leading to a tight coupling between the application
and the distribution framework.
To run the CORBA example, the ORB needs to be started and the server
bound to the ORB. Once bound, the client application connects to the ORB and
requests the service it is interested in by name. The ORB contacts the server,
which runs the request and sends the result back to the ORB. The ORB then
returns the result back to the requesting client.

2.4.4 Summary

CORBA has similar issues to RPC type systems in that the range of values that
can be passed between systems, either as arguments or return values, is limited to
those that can be represented in all of the implementation languages supported.
In addition, as with all IDLs, programmers have an additional language to learn
and an additional artefact to deal with. A limitation with the object-oriented
nature of CORBA is that objects are passed by reference not by value . There is
also no way to extend the range of permissible values transmitted on the fly and
still ensure that the value will be correctly interpreted upon receipt [122].
As can be seen in our simple CORBA example, Java's CORBA framework
imposes a large overhead as well as a great deal of complexity. As is common with
all frameworks, the CORBA framework is highly intrusive in nature, as illustrated
by the shaded areas in Figures 2.9 and 2.10, and results in CORBA specific code
tangled with the application's code making reuse of the application code extremely
dicult.

2.5 Java Remote Method Invocation (RMI)
Object-oriented systems are currently the dominant programming paradigm and
a number of distributed systems exist for object-oriented languages and systems.
Many of these systems use the RPC mechanism even though procedure calls, as
such, no longer exist in the object-oriented paradigm. Consequently many of these
systems do not provide object-oriented features, such as polymorphism, because
the RPC type paradigm only allows for the static representation of data [116].