 |
 |
 |
 |
| |
|||||
|
|
|
NITRO grew out of our work with NIMA in developing guidelines and prototypes for applying the principles of object-oriented technology in their end user environment. That initial set of tasks focused on three levels of integration:
NITRO has taken full advantage of maturing object technology standards and the revolution in information sharing represented in the new web technologies to become the next step in this work program. Figure 1 shows a schematic simplification of the NITRO architecture that has been prototyped here at MITRE and in our sponsor environment.
Figure 1. The simplified NITRO architecture There are several important technical points about NITRO architecture: (1) It relies on the Object Management Group's Object Request Broker (ORB) standard called CORBA (Common Object Request Broker Architecture). (2) It uses thin Java and browser clients that can be rapidly implemented. (3) It supports client access and integration of many servers in the architecture. (4) It uses object wrappers to integrate functionality of working servers with the creation of new, CORBA-compliant servers, and with the inherent cross-platform and cross-network features of the overall system. This technical approach means that extensibility at the client, server, and communication levels is in the very nature of the NITRO architecture. The NITRO architecture benefits from all the reusability characteristics of an object-oriented approach while retaining the flexibility of easily customized clients. NITRO is intended to stay ahead of NIMA's implemented systems. This means that the NITRO team can act as the leader for system development, and it also means that the NITRO architecture is always evolving. For example, while the current prototype and demonstration facilities emphasize Internet Inter-ORB Protocol (IIOP), CORBA, and Java, newer versions may incorporate Microsoft's Distributed Component Object Model (DCOM) and ActiveX controls. Other MITRE research has shown how interoperation via ORBs can be further extended by emerging web browser technologies. The CORBA standards on which NITRO is based have been embraced by many vendors such as Netscape and IBM. Several independent software vendors such as Iona, BEA, and Visigenic sell their own CORBA-compliant ORBs. Thus, the NITRO architecture draws heavily on COTS software and open systems standards. Coding the client means creating an active storage space that communicates with the servers through the CORBA bus and supports interaction of information and capabilities from different servers. Combination of the capabilities of different servers through the client supports user-controlled, mission-specific tailoring of functionality at the desktop. Because our NITRO clients are written in Java, we can code a client once and use it on many different platforms. Creating a new client currently requires some knowledge about which specific servers are available and what they do. However, as CORBA matures, client software will be able to query trader services, which will locate servers needed by the client on the CORBA bus. The server side of the NITRO architecture has three main parts. The most recognizable part consists of the capabilities that the client accesses. For our NIMA sponsor, this might be an image-processing application or a geospatial information systems tool. For research that the Open Systems Center is doing on MITRE's Intranet (MII), the capabilities might be a phonebook datamart or a metasearch engine. The second part of the server is the wrapper software, usually written in C++ or Java. Legacy code is wrapped with middleware code to translate between its existing application programming interfaces and the standard object interfaces facilitated by the CORBA standard. Once a legacy system has been wrapped, it has the potential to be used in many different CORBA-based systems. The final part of the server capability is represented in Figure 1 as the server-specific IDL. IDL is the CORBA standard Interface Definition Language description of the server's interfaces. These three parts form truly portable and extensible functionality that can be used by many CORBA-compliant systems. For more information, please contact Hays "Skip" McCormick using the employee directory. |
Solutions That Make a Difference.® |
|
|
The
technology of distributed object computing brings many phrases to mind:
Plug-and-Play, Reuse, Cross-Platform, Write Once-Run Anywhere, Information
Bus, Component-ware, NITRO. NITRO? Yes, NITRO -- National Imagery and
Mapping Agency (NIMA) Interoperable Technology Reification Objects (Reification
here means converting an abstract concept into a software entity). Or,
as we call it: NITRO, an explosion in interoperability.
