The Corba standard is winning acceptance in a broad range of industries, from financial services and manufacturing to transportation and defense sectors. And the driving force behind its new-found popularity is Java.

Corba is especially popular in the financial industry, says James Chong, VP of architecture at brokerage Charles Schwab & Co. These firms are crafting cutting-edge Java applications in highly distributed environments, and Corba (Common Object Request Broker Architecture) is letting them create standard communication mechanisms between applications and components.

A growing number of business developers are also turning to Corba object middleware to bring enterprise scalability to their Java applications.

Pratt & Whitney, a manufacturer of jet engines, adopted Corba to simplify application interoperability across the enterprise and increase programmer productivity, says Bob Landgraff, a computer specialist with this United Technologies Corp. subsidiary. By using Iona Technologies Inc.'s Orbix Corba software, P&W developers can use the same linking mechanism in every application, rather than write a unique remote procedure call for each application.

Even Microsoft, a reluctant member of the Object Management Group, the consortium responsible for Corba development, has grudgingly accepted this industry standard. Microsoft recently made a number of partnerships and licensing agreements to ensure interoperability between its proprietary Component Object Model and Corba.

Corba's sudden popularity is driven by businesses' need to build cross-platform, component-based applications that can be deployed over the World Wide Web. After a painfully slow evolution, Corba finally appears ready for production business environments.

Corba is component middleware that lets technical objects and business components find each other in a network environment and invoke their respective services regardless of the underlying platforms or languages on which the applications are running. Corba goes beyond the functions of a simple object request broker. It specifies a set of services (see chart, p. 351) that will let organizations build, modify, share, and manage distributed components.

With the Internet Inter-ORB protocol, which is part of the Corba standard, Corba finally delivers a distributed, enterprise communication backbone and en-sures interoperability among ORBs. IIOP is the communications language supported in both Corba and Java. IIOP runs on top of a TCP/IP transport mechanism.

A recent survey of 200 businesses by the Cutter Consortium market research firm found that Corba is the preferred object middleware by a margin of 2-to-1 over Microsoft's Windows-based COM. Of the Corba users, 61% were happy with the technology while 18% were still evaluating it. Overall, 70% reported having at least one major distributed object application while 41% reported at least one failed initiative.

Pratt & Whitney's Government Engines and Space Propulsion group in West Palm Beach, Fla., turned to Iona's commercial implementation of Corba instead of writing custom code. RPCs are custom, low-level calls that must be created new for each situation, Landgraff says. By using Corba, developers simply make standard, high-level calls to the Corba interface, while the low-level communications code is automatically generated by the Orbix tool.

P&W developers tried to write communications code without Corba. By the time they wrote the timing and error-handling routines, and other communications and linking functions, "we had a mountain of C++ code," Landgraff says. "We finally gave up." Corba provided a much more lightweight approach to application integration.

One of P&W's Corba applications handles the scheduling, planning, and control functions of all the group's engine design and manufacturing. Rather than build new functions, the developers wrapped a legacy application, turning it into a reusable Corba component. Developers simply call for the service provided by the component by name. The ORB identifies the requested component, forwards the request while making any required translations, and returns the results. Additional reports and extensions are developed as Corba objects.

Landgraff attributes P&W's success with Corba to its advanced programming skills. "We are very experienced. We have 15 very good object programmers who came out of our artificial intelligence projects," he says.

All Wrapped Up

After a year of researching Corba, First Union National Bank started a Corba project in January 1998. The bank has two major Corba applications: Customer Central, an object-based front end to its mainframe customer information system, and Document Central, a server-based document generation application.

Each application is a Corba component that wraps other things. For instance, Document Central encapsulates existing word processing functionality and adds a Corba interface, turning it into a Corba component that can be accessed through an ORB. For Customer Central, the developers similarly encapsulated an existing legacy application.

The clients for these applications are primarily Visual Basic applications, says Bill Barnett, First Union's manager of distributed application technologies. To make Corba work in the Microsoft application environment, the bank had to provide a Dynamic Link Library on the client side to make Corba appear as an ActiveX component. The bank turned to a commercial product, Visual Edge Software Ltd.'s Object Bridge, for the DLL that provides ActiveX-to-Corba transformation, and to Inprise Corp. for Corba support. "To the developer of the client application, it looks like ActiveX, but what comes out is Corba," Barnett says.

For First Union, Corba is a strategic part of its enterprise architecture. "It's important because it's both language--and platform-independent," he says. Still, the commercial implementations of Corba lack industrial-strength capabilities that high transaction environments like First Union's need, such as load balancing and failover. Corba has some rudimentary load balancing, but First Union really wants services on par with a transaction monitor, Barnett says. As the ORB vendors and transaction monitor vendors collaborate, Barnett expects Corba to acquire those industrial strength services.

Xerox Corp. turned to the combination of Corba and Java to create a human resources application to be accessed by employees via a browser over the corporate intranet. The application, called PeopleNet, lets employees review and change benefits, sign up for training, and take advantage of many human resources functions. The application frees the HR staff through user self-service for routine information requests, updates, and changes.

At first, Xerox tried to build the application using Java applets talking with database servers. Neither Java Database Connectivity nor sockets worked sufficiently well in making the back-end connection. Developers found what they needed in Corba. It let them build the Java front end and connect with Oracle databases without wrestling with low-level communications and database calls, says Jim Johnson, architecture manager for Xerox's human resources IT group.

Xerox's biggest problem was not with Corba, but with Java. "We had to download large Java classes," which wasn't acceptable, says Johnson. The solution was to cache the Java classes--400 Kbytes' worth--on the client. In this way, the classes are downloaded only once. The application also uses HTML for static information. The majority of Xerox's 37,000 users, however, still access the application through a Visual Basic client application rather than a browser. The VB client application is 40 Mbytes--100 times the size for the same functionality of the Java classes and Corba code.

Xerox developers took 12 months to create the PeopleNet Java client and Corba middle tier. The application consists of 35 functions, each a Java applet or HTML page. Despite the big installed base of Visual Basic clients, Xerox developers avoided Microsoft's COM because the IT department is dependent on Oracle and Unix servers, while COM works only in the Windows environment.

Despite successes like these, Corba's ultimate success is not a foregone conclusion, and developers and analysts continue to complain of problems. "The core pieces of Corba are there, but it still needs a lot of help," says Sally Cusack, an analyst with SPG Analyst Services. Cusack has found that Corba works well for tightly defined transactions, but isn't sufficiently flexible for online, real-time processing.

A senior developer at a major overnight delivery company in California used Corba to build its first distributed component application. The effort took six months for the modest application, after which the team declared it a success. The application works as long as the client is using the recommended browser and nobody tries to port the application to a different vendor's ORB. Developers hope the Corba industry will eliminate such pesky problems as ORB interoperability and browser constraints.

October marks the seventh anniversary of Corba, and the OMG early next year will roll out Corba 3.0. Given the maturity of the technology, Corba proponents find it hard to excuse Corba shortcomings as the problems of immaturity.

Expertise Required

Corba isn't for the casual development shop. While the Corba interface definition language, which specifies the actions a Corba component can take, looks disarmingly simple--a declarative, macro-like language with only a handful of commands--it represents only the starting point. Developers then have to write the C++ or Java client and server code, referred to as skeletons or stubs, that implements the IDL for the front and back applications. For this, the organization needs to buy or patiently cultivate the object-oriented programming skills that are in such great demand today.

Corba's distributed object services have not lived up to user expectations. The Corba event service, for example, is a critical service for applications that are intended to automate a complete business process. The event service lets Corba objects dynamically register their interest in specific events. For example, when a loan origination object is invoked, the credit-checking object might want to know, so it can begin the mandatory credit check.

"We tried to use the event service, but there were some problems and we ended up writing our own," says Sundar Swaminathan, a senior IT manager at the Sabre Group. Swaminathan's team is about to deploy a real-time, cargo logistics management application. It uses Corba as the middle tier communications middleware, which eliminated the need for the developers to write low-level communications code. Eventually, Swaminathan intends to swap its homegrown event service for the Corba event service.

Sabre Group's application runs on a Windows NT client and server with an Oracle database. It seems like a natural for Microsoft's COM approach to component interoperability, but the developers opted for Corba instead, despite its weaknesses. "We wanted to be sure that Windows clients could talk to Unix servers if it got to the point where we needed real server horsepower for scalability," Swaminathan says. COM lacks the cross-platform interoperability the developers wanted.

Software companies have gravitated to Corba as a way to minimize coding and emerge as a leader in a hot technology space, says Bob Bickel, senior VP at Bluestone Software Inc., an application server vendor. For software vendors, Corba eliminates some low-level coding and solves some nagging cross-platform interoperability problems as well as generally expediting component-based development.

Still, some of these early adopters are approaching Corba with caution. For example, DBS Systems Inc., a provider of high-volume transaction processing systems to the telecom industry, is building its next generation systems using Dynasty and Corba as the component middleware. But it's hedging its bets. "We will have 12 to 15 major components and a Corba backbone if the customer wants it," says William Guinn, DBS's chief technical director. However, the product will be middleware neutral--supporting Corba, Tuxedo, or TCP/IP sockets, Bickel says. Although inherently different, each of these technologies can be used to build multitier, distributed enterprise applications.

DBS can be flexible because it is building its components in Dynasty. "With Dynasty, we can choose which middleware we want to support and just push a button. No matter what middleware wins, we win," Guinn says. "We looked at Corba alone, and it was just too much work," he adds.

The DBS customers who opt for the Corba version will be those who have to interface to other vendors' products. "These customers want a lot of interoperability, but it comes at a cost," Guinn says. The extra cost results mainly from the amount of server resources Corba consumes.

To-Do List

The list of things Corba still needs is long: universally implemented enterprise services, such as event and transaction services; tools to provide higher levels of abstraction for ease of development; and improved portability and interoperability.

But for organizations that have waited this long for a useful Corba, a few more years won't matter as long as they can start building real business applications with Corba today, which is exactly what a growing number of organizations are doing. It isn't easy or foolproof, but it's the best available option.

Naming: Allows objects to find other objects through the object request broker, similar to a telephone book's white pages.

Security: Addresses all aspects of distributed object security, including authentication, authorization, audit, credentials, and encryption.

Transactions: Defines interface definition language interfaces, which allow multiple distributed objects on multiple ORBs to participate in atomic transactions, allowing an ORB to act like a TP monitor.

Events: Allows objects to dynamically register or unregister their interest in specific events for the purpose of notification.

Life cycle: Operations for creating, copying, moving, and deleting objects.

Object trader: Lets objects discover other objects based on the services they provide, similar to the telephone book's yellow pages.

Concurrency: Coordinates and controls access to shared resources through the use of locks.

Persistence: Allows the state of an object to be saved in a storage facility and restored when needed.

Externalization: Defines interfaces for externalizing an object to a stream and internalizing an object from a stream. A stream is a data-holding area associated with a cursor, a mobile pointer.

Query: Allows an application to search for objects based on attributes specified in a query.

Collection: Allows groups of objects to be manipulated collectively rather than individually. Collections include queues, stacks, lists, and arrays.

Object relationships: Dynamically creates and tracks relationships between objects that know nothing of each other. Relationships are created without changing the existing objects or requiring that an object add a new interface.

Time: Allows the ORB to obtain the current time, ascertain the order in which events occur, generate time-based events, and compute the interval between two events.

Licensing: Enforces a wide range of licensing options and collects component usage metrics.

Property: Dynamically associates a named attribute with a shrink-wrapped component.

The maturation of the Internet Inter-ORB Protocol promises to finally bring Corba into the mainstream of Web application development. IIOP is the TCP/IP protocol with some Corba-defined message exchanges included.

It forms the underlying communication protocol that provides common backbone communications for interoperability between components.

"IIOP has given Corba a tremendous boost," says Sally Cusack of SPG Analyst Services. When and if it's fully implemented by the object request broker vendors, IIOP should eliminate the problem of interoperability and portability between ORBs.

Corba vendors are betting that IIOP interoperability for Corba and the implementation of a diverse set of distributed object services will usher in Corba's golden age. But even its proponents concede that Corba is a tool for expert programmers to use in generating complex multitier systems.
--Alan Radding

PHOTO (COLOR): Taking a chance: Sabre Group opted for Corba as its middleware despite its flaws, Swaminathan says.

PHOTO (COLOR): Think first: First Union implemented Corba strategically, says manager Barnett.

~~~~~~~~

By Alan Radding