[Search for users]
[Overall Top Noters]
[List of all Conferences]
[Download this site]
| Title: | ObjectBroker Desktop Connection |
|
| Moderator: | RECV::STORM |
|
| Created: | Mon Jan 06 1997 |
| Last Modified: | Thu Jun 05 1997 |
| Last Successful Update: | Fri Jun 06 1997 |
| Number of topics: | 40 |
| Total number of notes: | 125 |
29.0. "HP's CORBAConnect" by ENQUE::PARODI (John H. Parodi DTN 381-1640) Tue Mar 04 1997 08:51
This is HP's CORBAConnect product, based on the Visual Edge Object
Bridge.
HP CORBAConnect
A technical white paper on the Premier OLE/COM-CORBA Interoperability
Solution
* Product Overview
* Features
* Competitive Analysis
* Usage Scenarios and Examples
---------------------------------------------------------------------------
Product Overview
The rapidly growing Internet client/server market provides companies with
exciting new opportunities to deliver products and services directly to
employees and customers. In capitalizing on these opportunities to quickly
gain competitive advantage, IS managers are faced with a serious challenge:
how to minimize the overall cost involved in updating traditional
desktop-centric, proprietary systems in favor of an open, Web-centric
corporate network.
To meet this challenge, Hewlett-Packard offers HP CORBAConnect (TM) -- an
interworking solution that provides seamless integration between
applications running on Microsoft Windows desktops and CORBA
applications/protocols. This software package is designed for customers who
want to take full advantage of the distributed power and open architecture
of the Internet to build client/server applications using CORBA, while
leveraging their investments in existing Microsoft Windows desktop systems.
HP CORBAConnect is a complete, standard-based OLE-CORBA interworking
solution. It provides seamless interoperability among previously
incompatible software systems - enabling corporations to significantly
reduce the cost of integrating their various elements of software and
platform infrastructures. With the Object Bridge, developers can use the
object system they already know to create applications that combine the
best components available -- without any source code modification.
back to top
What is it?
HP CORBAConnect is an interworking solution that is fully compliant with
the OMG's COM-CORBA Interworking Specification. It provides complete,
bi-directional interoperability among OLE, COM and CORBA object systems. In
addition, the product supports the OMG Internet Inter-ORB Protocol (IIOP)
for communication across the network. CORBAConnect makes it easy for
developers to use a CORBA object from OLE or COM, or an OLE or COM object
from CORBA. The conversion between object systems is performed in
real-time, and is completely transparent to both developers and users.
The package includes an easy-to-use GUI that provides access to all product
functionality, as well as a ``Just-In-Time'' (JIT) compiler to ensure
optimal performance. The GUI object browser allows developers to select and
install objects and CORBA shared services through a simple ``point and
click'' operation. This ease-of-use feature enables developers to use
foreign objects without having to learn an unfamiliar system. For example,
Visual Basic(TM) programmers do not have to learn CORBA IDL, CORBA types or
CORBA services -- rather, they see and use familiar OLE, COM, or ActiveX
objects -- which minimizes training costs significantly.
By enabling developers to connect Microsoft Windows clients to CORBA
networked objects, the Object Bridge provides desktop users with the
ability to transparently access enterprise data and applications stored on
the corporate Web. In addition, by providing Windows users and developers
with access to CORBA shared services from their native Microsoft Windows
environment, HP CORBAConnect allows corporations to preserve their existing
investment in Microsoft Windows desktops as well as leverage the
programming skills of their Microsoft Windows developers.
How Does it Work?
HP CORBAConnect uses advanced Just-In-Time (JIT) compilation technology to
achieve the utmost in performance and simplicity. When developers select a
class for use in another object environment, HP CORBAConnect automatically
examines the description of the class. It then generates a Just-In-Time
compiled proxy on demand, based on that description.
Each object system -- OLE Automation, COM and CORBA -- has a corresponding
Object System Adapter (OSA). When a call passes from one object system to
another, HP CORBAConnect uses the two corresponding OSAs to perform the
conversion in a single step, quickly and transparently.
The OSA is analogous to a compiler front end. It is responsible for reading
the native format description of the class and passing that description to
the JIT back end. In addition, the OSA is responsible for managing details
required to ensure robust, production-quality operation for the objects in
its corresponding object system. Examples of these details include proxy
loop detection and reference counting/garbage collection.
---------------------------------------------------------------------------
Features and Benefits
* Fully compliant industry-standard interoperability -- and more
HP CORBAConnect provides a strict superset of the Object Management
Group's (OMG) COM/CORBA Interworking Specification. In specific terms,
it is a fully compliant bi-directional interworking solution between
CORBA and both OLE Automation and COM. This is an important
distinction, because many companies that claim to support the
specification only do so for interoperability from CORBA to OLE
Automation, and not vice versa. In other words, these solutions rely
on a non-standard, proprietary mapping to achieve the reverse OLE
Automation to CORBA interoperability, thereby locking customers into
that particular vendor's approach for the entire project and barring
them from using complementary tools to complete the job. Moreover, COM
interworking is not supported by any solution other than HP
CORBAConnect.
Full COM support is extremely important, because ActiveX is based on
COM -- not OLE Automation. With HP CORBAConnect, customers are assured
of a complete interoperability solution that provides open interaction
with a wide range of systems and technologies, so investments are
fully protected. Programmers are not ``pigeon-holed'' into an awkward
coding methodology that is unfamiliar to them. OLE developers do not
have to learn CORBA services (and vice versa), nor do they have to
spend valuable time compensating for shortcomings in an
interoperability tool. By supporting both OLE Automation and COM, HP
CORBAConnect provides corporations with the utmost in performance as
well as the ability to choose the programmers best suited to the task:
Visual Basic(TM)/4GL programmers, or C++/COM programmers. This results
in significantly lower training and development costs.
* Easy to use
HP CORBAConnect provides unparalleled ease of use and significantly
reduces developer training costs. For example, a WYSIWYG object
browser enables Windows developers to effortlessly browse and select
the CORBA classes they want to install in OLE. OLE developers never
have to learn CORBA IDL, CORBA types or CORBA services because all
CORBA objects displayed are indistinguishable from familiar OLE, COM
and ActiveX objects. Similarly, CORBA developers can utilize OLE
objects without having to work with COM MIDL or type libraries.
Instead, they see true, familiar CORBA objects. The same goes for
Visual Basic developers; with CORBAConnect, they can gain
high-performance interoperability without having to generate, utilize
or learn C++.
* Works with existing objects
HP CORBAConnect enables developers to work with any existing OLE or
CORBA object. Unlike competing offerings, HP CORBAConnect does not
require the time-consuming hand-coding of complete ``wrapper'' objects
in order to take advantage of existing OLE objects. Developers can
work with the tools they are familiar with, using the methodology they
already know, and yet still gain full, production-quality
interoperability. No other interoperability solution provides this
level of investment protection.
* Designed for production usage, not just prototyping
HP CORBAConnect is designed to scale from prototyping through to
large-scale, robust production-quality usage. Unlike other tools that
only generate simple stub code, HP CORBAConnect provides the features
production-quality applications require, including: proxy loop
detection, name collision management, versioning support, full
exception and error handling, support for asymmetrical mappings, etc.
With HP CORBAConnect, investment is not lost as programmers move from
prototyping through development to production-quality deployment.
* Low life-cycle costs
HP CORBAConnect addresses more than just development issues; it offers
the lowest overall life-cycle costs of any tool on the market. In
addition to the lowest initial application development cost, HP
CORBAConnect provides features to smoothly move developers from
development to deployment. Moreover, as the application evolves, HP
CORBAConnect provides special features to help manage versioning and
to help maintain backward compatibility. With HP CORBAConnect,
developers can be sure they have made the right economic choice for
their interoperability solution.
* High performance
Through HP CORBAConnect's advanced Just-In-Time (JIT) compiler
technology and its ability to directly support full COM
interoperability, developers gain performance levels that are
unmatched by competing offerings. HP CORBAConnect is not only the most
complete and easiest-to-use choice, it also provides the highest
performance -- and that means the best responsiveness for end-user
applications.
back to top
---------------------------------------------------------------------------
Competitive Analysis
The tools on the market today offer different levels of OLE-CORBA
interoperability. The following provides information on how to distinguish
among the various interoperability solutions offered by competing vendors.
The Different Levels of Interoperability
The Object Management Group has developed a standard for OLE-CORBA
interoperability. Called the COM/CORBA Interworking Specification, this
standard is meant to provide customers with a benchmark for evaluating
interoperability solutions so that they may make an informed choice -- and
hopefully avoid the danger of being locked into a proprietary solution.
The COM/CORBA Interworking Specification has two distinct elements. The
first specifies OLE Automation-CORBA interoperability; the second specifies
COM-CORBA interoperability. For each part, the specification outlines two
levels of interoperability: mapping and interworking. (This is explained in
more detail below.)
OLE Automation is the portion of the OLE specification designed to
facilitate the manipulation of objects via scripting languages. It offers a
limited range of data types and is relatively low in performance, but it's
easy for systems developers to program. COM, on the other hand, is designed
to offer a complete range of data types and to be very high in relative
performance -- it is essentially `stylized' C++ coding, and thus is more
difficult to program. In between OLE Automation and COM is something called
``dual interfaces'' which adds high-performance COM method calling to OLE
Automation, but still restricts the range of data types that may be used.
The distinction between OLE Automation, dual interfaces, and COM is
important to understand. Some interoperability solutions support only OLE
Automation-to-CORBA interoperability. As a result, they provide limited
capabilities and relatively poor performance. In distributed systems, full
COM support is required for optimal performance. Although the performance
of dual interfaces is fast relative to OLE Automation for local method
calling, it is slow in comparison to COM for distributed systems. The
reason is that dual interfaces still restricts the range of supported data
types. In fact, with dual interfaces, structures must be represented as
objects, so every remote structure member accessed requires a round trip
back to the originating location.
Naturally, HP CORBAConnect supports full CORBA interoperability for both
OLE Automation and COM (including dual interfaces), and thus ensures the
highest possible performance.
Another important factor to consider when evaluating interoperability tools
is whether they provide one-way or two-way interoperability. According to
the COM/CORBA Interworking Specification, a uni-directional (one-way)
interoperability tool is called a mapping solution, and a bi-directional
(two-way) tool is called an interworking solution. A uni-directional
mapping solution makes objects in one system available to another system,
but not the reverse. For example, a mapping solution might make CORBA
objects available to OLE, but not OLE objects to CORBA. An interworking
solution is what's required for true bi-directional interoperability.
HP CORBAConnect is a fully compliant interworking solution for CORBA and
both OLE Automation and COM. It provides complete bi-directional
interoperability, eliminating the need for classes to be re-worked or
``force fit'' to compensate for the limitations common to other tools.
Two One-Ways do not Make a Two-Way
When comparing interoperability products, it is important to note that a
vendor offering two mapping tools -- one for each direction -- is not
offering a true interworking (bi-directional) tool. The reason is that
classes frequently pass or return objects in methods and properties.
One-way tools (even two one-way tools used in combination) cannot handle
such classes.
For example, assume that a real CORBA class, with a property of type
object, has been made available to OLE via a one-way tool. Because the
class appears in OLE, an OLE programmer using the class would expect to be
able to set the value of the property to be an OLE object. Unfortunately,
the one-way tool provides no facility to convert that OLE object back into
CORBA, so the operation will not work.
Two one-way tools used together can make objects available to each system,
but their capabilities cannot be mixed -- even when used in combination,
they do not support any class that has:
* An object for a property;
* An object as an argument to a method; or
* An object as an argument to an interface.
This is a substantial limitation which relegates one-way tools (even two
one-way tools) to prototyping situations.
To develop production-quality software, developers must use a fully
compliant interworking solution (a two-way, bi-directional tool). Mapping
tools alone are not equal to the task.
back to top
What Does ``Fully Compliant'' Mean?
Virtually all vendors that provide interoperability capabilities use
marketing phrases such as ``fully compliant'' and ``100% compliant'' --
even though the level of capabilities and compliance they provide varies
greatly. Therefore, it is important to ask questions that will enable you
to determine what level of functionality a vendor really does offer.
For example, a vendor touting compliance with the OMG's Interworking
Specification might, in fact, offer a compliant OLE Automation mapping
solution (CORBA to OLE), a proprietary OLE Automation-to-CORBA mapping
mechanism, but no COM-to-CORBA interoperability capability. Be sure to get
specifics on each element before assuming that any vendor is using the term
``fully compliant'' properly.
HP CORBAConnect provides a strict superset of the entire OMG Interworking
Specification. It is the only full interworking (bi-directional) technology
on the market that provides 100% compliance with both OLE Automation and
COM. With HP CORBAConnect, customers are assured of complete
interoperability.
Achieving Seamless Interoperability
Of course, there is more to achieving seamless interoperability than simply
following the OMG's Interworking Specification. Toward this end, HP
CORBAConnect provides numerous additional interoperability features that
significantly enhance ease of use. For example, both OLE and CORBA have
their own standards for providing asynchronous event capabilities. OLE
provides an event mechanism with ActiveX controls called ``connection
points''; CORBA provides a different event mechanism called ``event
channels.'' In order to ensure seamless interoperability, event semantics
must be mapped across systems -- which is exactly what HP CORBAConnect
does.
In OLE, if an ActiveX control provides a connection point, code can be
written (with a tool such as Visual Basic) that will execute when that
event is triggered. Said another way, when the ActiveX object triggers its
event, another developer's code -- the Visual Basic programmer's -- is
executed.
Events are ubiquitous. But what happens when a class with an event is made
available in another system? Some vendors map the event object classes
directly from one object system to another. That is, they make CORBA
programmers learn the arcane semantics of OLE connection points, and/or
they make OLE programmers learn the equally restrictive language of CORBA
event channels. Moreover, they make programmers use these systems
``manually'' -- since, for example, no Windows development tool would
recognize an event channel (although it would know how to handle ActiveX
connection points). Obviously, this type of solution is not desirable.
HP CORBAConnect makes bi-directional event mapping easy for developers. If
a CORBA object with an event is installed in OLE, its event channel is
mapped into a connection point. This means that OLE developers can work
entirely in the system they are familiar with, and OLE tools work
effectively and productively (enabling OLE code to execute when the CORBA
event is triggered or vice versa). The Object Bridge is the only OLE-CORBA
interoperability technology to offer this capability.
---------------------------------------------------------------------------
Usage Scenarios and Examples
The following typical usage scenarios for HP CORBAConnect illustrate the
basic elements of using HP CORBAConnect, and show how easy the product is
to master.
* An OLE Client and a CORBA Server
* An OLE Server and a CORBA Client
* A CORBA "ActiveX Control" in a Web Page
back to top
An OLE Client and a CORBA Server
In this scenario, a CORBA server provides customer information. It is
accessed from OLE, as an OLE server, by a Visual Basic program (an ActiveX
example is shown later). The CORBA object has the following definition in
IDL. The code in the IDL is a simple example of a Customer data service
that shows:
* A user-defined data structure
* String and long data types
* A return type of sequence
* An in parameter
// Definition of the customer structure.
struct Customer
{
string name;
long id;
string address
};
// Server for customer data.
interface CustomerServer
{
// Method to return the list of customers
sequence<Customer> get_customer_list();
// Method to look up a customer by name
Customer get_customer(in string name);
};
In this example, the object is already installed in the CORBA Naming
Service. Now, there are a few steps that are necessary in order to make
CORBA classes available in OLE. They are:
1. Find the desired classes using the GUI object browser (see Fig. 2
below); when you select a method of the CORBA object, you see its
Visual Basic (or other) declaration in real time.
2. Group the selected classes together into the OLE ``service'' (i.e.
server) as required.
3. Choose the service and expose it to both OLE Automation and COM.
In addition, bindings may be generated for the particular programming style
used. In this Visual Basic example, it is necessary to generate a Type
Library for optimal performance using a dialog box selection. The process
is completely automatic.
The code illustrated above is in a style completely familiar to Visual
Basic programmers -- it appears as if the CORBA class was actually
implemented entirely in OLE. This familiarity and ease of use translates
directly into low training costs.
To facilitate application deployment, HP CORBAConnect generates install
scripts. This feature significantly reduces the time and cost associated
with installing CORBA objects in OLE on each desktop. With HP CORBAConnect,
the entire life cycle is addressed to ensure that overall costs are the
lowest of any interoperability product on the market.
back to top
An OLE Server and a CORBA Client
In this example, a CORBA client retrieves stock quote data and utilizes
Excel to graph the information.
To employ Excel from CORBA, as above, developers select the desired Excel
classes in the GUI object browser and specify that they should be installed
in CORBA. Next, they choose to generate an IDL binding so that the class
may be used from C++.
The CORBA C++ code appears as follows:
boolean UpdateExcel(Excel::Series *chartSeries)
{
// Find the number of data points
int dataCnt = DataCount();
// Copy the data into a CORBA sequence
Types::StatsData data(dataCnt);
for(int i = 0; i < dataCnt; i++)
data[i] = GatherData(i);
try
{
// Update the Excel chart's data series
CORBA::Any dataInAny(Types::_tc_StatsData, &data);
chartSeries->Values(dataInAny);
}
catch(CORBA::Exception &excep)
{
// Excel update failed, return false
return FALSE;
}
return TRUE;
}
As is evident, the code appears as if Excel were implemented in CORBA. This
simplicity represents a substantial advantage over competing tools. To
accomplish the above with competing tools today (if even possible),
developers would have to:
1. Use the Excel type library and manually generate IDL;
2. Generate a C++ support library and an ``empty'' VB class from the IDL;
3. Compile the C++ code using Visual C++ (which is not only a complicated
endeavor, but forces the Visual Basic developer to buy and learn to
use a specific version of Visual C++);
4. Load the generated class into Visual Basic, and then for each method,
write code to convert the parameters and to call the corresponding
Excel method (as well as to generate a ``CORBA-style'' exception if an
error occurs);
5. Generate a VB executable; and
6. Manually install the above server in the CORBA vendor's interface and
implementation repositories;
The difference is clear -- the effort and costs involved with a non-Object
Bridge approach are substantial, and should not be overlooked.
back to top
A CORBA ``ActiveX Control'' in a Web Page
In this example, the same CustomerServer class from the previous examples
is used -- but as an ActiveX control in a Web page. The Web page displays a
list of customers for the user to select.
To create an ActiveX control from the CustomerServer class, developers
follow the same steps as described in the first example. The only
difference is that they opt to create an ActiveX control instead of an OLE
server. Once these steps are completed, the ActiveX control is immediately
available for use.
As with any non-visual ActiveX control -- like a timer -- developers can
add the control to their Web page using any ActiveX-enabled Web authoring
tool. If the name for the new control were to be set to CustServer1, Visual
Basic for Applications code in a Web page initialization routine might
appear as follows:
...
Dim Cust As Customer
Dim Customer_List As Variant
Customer_List = CustServer1.get_customer_list
For i = LBound (Customer_List) To UBound (Customer_List)
' Loop through the list of customers
Set Cust = Customer_List (i)
My_Combo_Box.AddItem(Cust.name)
' Add all customer names to the Combo Box on the Web page
Next i
...
As these examples show, HP CORBAConnect is not only the most robust
interoperability solution available, but is also the easiest to use --
which is a significant competitive advantage when training and overall life
cycle costs are factored into the equation.
back to top
---------------------------------------------------------------------------
Conclusion
Hewlett-Packard's HP CORBAConnect is based on Object Bridge(TM) technology
from Visual Edge. Of the various ``interoperability'' products on the
market, the Object Bridge is the only bi-directional interworking solution
that can honestly claim full compliance with the OMG's COM-CORBA
Interworking Specification. This simple fact carries significant
implications, for only a truly standards-compliant solution can produce
production-quality results. More to the point, only a standards-compliant
solution for both OLE-CORBA and COM-CORBA interoperability can ensure
maximum performance, offer complete investment protection, leverage
existing resources and save on project costs through increased productivity
and software reuse.
As the only standards-compliant interworking solution on the market that
can deliver all of these benefits, HP CORBAConnect is garnering enormous
attention from the software development community. In practical terms, it
represents a new breed of technology designed to significantly lower the
cost of integrating, configuring and administrating the diverse software
infrastructures within today's enterprise environments. This means that,
for the first time, corporations can create an ``enterprise-wide''
integrated software infrastructure that will enable them to capitalize on
the distributed power of the Internet while leveraging investments they
have made in existing systems.
Moreover, by delivering the benefits of software reuse, HP CORBAConnect can
provide savings of 15%-25% on project costs, thereby paying for itself in
short order. And finally, by virtue of its suitability for
production-quality use, HP CORBAConnect ensures that companies are not
simply reducing their initial development costs, but their overall life
cycle costs as well.
back to top
---------------------------------------------------------------------------
| T.R | Title | User | Personal
Name | Date | Lines |
|---|
| 29.1 | | SEND::STORM | | Tue Mar 04 1997 22:56 | 17 |
| John, thanks for posting this. Did they mention anything about
product availability??
From a quick read of this, the slam on "non-conforming" mappings
of Corba to COM is aimed at IONA.
The one shortcoming I see is they are claiming events, which we will
not have in V1.0
Of course, we now have the advantage over HP in this area because
WE ARE A SOFTWARE COMPANY. :-)
Mark,
A of CORBa
|
| 29.2 | | ENQUE::PARODI | John H. Parodi DTN 381-1640 | Wed Mar 05 1997 08:50 | 385 |
|
Mark,
It looks like it's available now (though you might get the same
impression from looking at DTC on our website). By the way, they
are allowing people to download ORBPlus in its entirety (for HP-UX,
Solaris and Win32) though it times out on 9/30/97.
I agree the marketing is aimed at Iona. As an aside, I asked Peter
Drivas why (given that ORBPlus has IIOP, DCE-CIOP, CORBAConnect, and
the HP cachet) ORBPlus doesn't dominate the ORB market. All he said
was that the original ORBPlus release in April '96 went almost
unnoticed by the market. So maybe all that is going on now is an
attempt to change that.
Near as I can tell, CORBAConnect does not have the visualization
features that DTC has. Is that correct? I'd like some sort of
differentiator to talk about in front of the Uniforum crowd next week.
I've attached HP's product brief for ORBPlus below. Or check it out at
http://www.software.hp.com/ (follow the HP Applications and Demos link
from there).
JP
---------------------------------------------------------------------------
HP ORB Plus 2.5
For HP-UX, SunSoft Solaris, and Microsoft� Windows� NT and 95
Product Brief
[Image]
Makes distributed applications easier to design, develop, manage, and
evolve.
HP ORB Plus 2.5 is an object distribution development tool designed for C++
application developers creating either enterprise-wide or embedded systems
applications. It is a fully threaded, scaleable implementation of the
Common Object Request Broker Architecture (CORBA) 2.0 industry standard for
object request brokers (ORBs). HP ORB Plus 2.5 is one of a growing family
of Internet object technology products that complement HP's complete
Internet products and services.
---------------------------------------------------------------------------
Features
Runtime Functionality
* Small-footprint, fully threaded object request broker
* Supported on HP 9000 (HP-UX 10.01, 10.10, and 10.20), Solaris 2.4 and
2.5.1, Windows NT 3.51 and 4.0, and Windows 95
* HP CORBAConnect: translation between CORBA objects and OLE Automation,
COM and OCX objects
* CORBA 2.0 Internet Inter-ORB Protocol (IIOP) transport for all
supported platforms
* Distributed Computing Environment Common Inter-ORB Protocol (DCE CIOP)
transport for HP-UX platforms
* Multi-transport independent object locator
* Dynamic invocation interface (DII)
* Dynamic skeleton interface (DSI)
* Interface Repository (IR)
* Object Management Group (OMG) CORBAservices available on all
platforms: Life Cycle, Naming, Events, and Trader; additionally on
HP-UX: Transactions
* Security API
* System administration management (SAM) for HP-UX
* Online documentation
Developer Toolkit
Runtime functionality plus:
* HP Enterprise Wizards
* Simple object adapter
* Interface definition language (IDL) compiler
* CORBA 2.0 C++ mapping
* Sample application suite
---------------------------------------------------------------------------
Product Overview
HP ORB Plus 2.5 follows a framework approach that allows developers to
select the components needed to make their distributed applications work
most effectively and efficiently. Application developers have the choice of
incorporating only those object services that are needed in the
application.
A fully threaded implementation of the CORBA 2.0 specifications, HP ORB
Plus 2.5 supports distributed C++ applications on a variety of platforms.
It provides a quick-response-time ORB whose small memory footprint scales
according to the features chosen and the application's requirements. This
makes HP ORB Plus 2.5 especially attractive for both embedded system
control applications and large-scale enterprise-wide applications.
HP ORB Plus 2.5 includes support for two transports:
* Using the IIOP, which meets the CORBA 2.0 interoperability standard,
HP ORB Plus 2.5 will interoperate with other leading ORB products.
* Those developing in HP-UX environments have the additional capability
of using the DCE CIOP.
HP ORB Plus 2.5 includes OMG CORBAservices: Events, Naming, Life Cycle, and
Trader. Those developing in HP-UX environments have the additional
capability of using the Transaction service.
---------------------------------------------------------------------------
Key Benefits
Investment Protection
HP has a history of commitment to standard technology as a means of
reducing cost to users. Our continuing commitment includes the CORBA
standards from OMG.
HP Enterprise Wizards, add-ins to the Microsoft Developer Studio, enable
developers using this popular environment to move into CORBA object server
development in a seamless fashion.
HP's support of the DCE RPC in HP ORB Plus 2.5 protects investments already
made in that technology as well as those made in network administration.
Interoperability
HP CORBAConnect is an interoperability feature between CORBA objects and
OLE Automation, COM and OCX objects. It leaves open significant options for
developers while furthering investment protection. HP CORBAConnect allows
messaging between OLE Automation, COM and OCX objects running in the
Windows environments and CORBA objects running in HP ORB Plus 2.5
environments. OLE Automation/COM/OCX developers continue to access CORBA
objects throughout the enterprise from within their familiar OLE
Automation/COM/OCX development environments.
HP also extensively tests HP ORB Plus with other object request brokers and
object distribution products to ensure interoperability.
---------------------------------------------------------------------------
Key Advantages and Features
Flexible Transports
HP ORB Plus 2.5 supports both CORBA 2.0 IIOP and DCE CIOP communications
protocols. For customers with existing DCE infrastructure, the DCE CIOP
support in HP ORB Plus 2.5 protects that investment. The IIOP protocol is
available for those customers who have chosen not to use DCE or require
interoperability with other ORBs supporting IIOP. HP ORB Plus 2.5 can also
be configured to use both transports simultaneously.
The DCE standard provides an integrated set of services that can be used
separately or together to provide a distributed computing environment that
is easy to administer. The CORBA specification provides a standard for how
objects (in applications, repositories, or class libraries) make requests
and receive responses across a distributed network.
Designed for Performance
Performance of HP ORB Plus 2.5 is maximized through several design
features. HP ORB Plus 2.5 is a fully threaded ORB. It supports the native
threading package available on each system. This is accomplished via a
thread abstraction layer. Thus, HP ORB Plus 2.5 can achieve the best
performance possible on platforms with efficient threads implementations.
When the client and server objects exist in the same process, HP ORB Plus
2.5 bypasses the transport stack, resulting in improved round-trip
communication throughput. The call overhead in this situation is on the
order of a virtual C++ method invocation.
Simple Object Adapter (SOA)
The SOA is the primary interface that implementations use to access HP ORB
Plus 2.5 functions. It supports a variety of common object implementations,
allows them to register with the ORB, keeps track of active objects within
those implementations, and monitors client-to-object communications.
IDL Compiler
HP ORB Plus 2.5 provides an IDL compiler that compiles CORBA IDL files into
stub and skeleton C++ code that conforms to the OMG C++ mapping. In
practice this means that the IDL compiler generates several source code
files, which are then included during compilation of an application. The
files declare C++ classes along with a skeleton of the class definition.
A user will fill in the skeleton with method definitions at a later time.
The IDL compiler can also generate type files, which allow other C++
classes to make use of the classes, and stubs, which are empty definitions
of the methods that accompany each class. A user will later add code that
implements the method. The ORB uses these files to ensure that a request
from a client is matched with the appropriate interface when the server
object receives it.
Interface Repository (IR)
Interface Repository (IR) is the ORB component that provides persistent
storage of IDL specifications and maintains interface objects. When using
the Dynamic Invocation Interface to invoke requests at runtime, the client
application can search the IR for operation names, types of arguments, and
return values instead of hard coding them into the program. Using the
Interface Repository, developers can persistently store IDL specifications
that applications can access at runtime.
Dynamic Invocation Interface (DII)
The Dynamic Invocation Interface (DII) functions as a generic client stub
and allows clients to invoke operations on an object reference without
using a cidl generated stub. Also, DII allows clients to make deferred
synchronous and one way requests on objects.
Dynamic Skeleton Interface (DSI)
The Dynamic Skeleton Interface (DSI) is a way to deliver requests from an
ORB to an object implementation that does not have compile-time knowledge
of the type of object it is implementing. It is the server-side counterpart
of the client-side DII.
DSI provides the basic support for building inter-ORB bridges that support
interoperability between CORBA-compliant ORBs in different domains.
Object Locator
The object locator provides transparent location for server objects running
in a network. The object locator locates the server process and objects
within a server process. When a server process starts up, it registers
itself and the objects it supports with the object locator. When a client
makes a request on an object and cannot determine the location of the
object, the object locator is queried to find the location of the process
associated with the object reference. The client then uses this information
to route the request to the object in the server process. The object
locator can activate the service process and objects if required.
OMG CORBAservices
Object services fit into a distributed object framework between the ORB and
the user environment. The application developer takes advantage of this
larger framework to construct a distributed application utilizing a slim
ORB connected to the one or more transport layers needed, the selected
object services, and the appropriate parts of the user environment.
HP ORB Plus 2.5 includes five services that comply with the OMG
CORBAservices standard. The application developer can select only those
needed. These services are:
* Event--A service that allows objects to notify each other of an
interesting occurrence such as a change in state.
* Naming--A federated service for assigning each object a unique
user-friendly name when the object's identity needs to be known by
others.
* Life Cycle--A service that specifies standard ways for objects to
participate in activities such as create, delete, link, and copy.
* Trader--A service that facilitates dynamic binding between objects
that advertise their services with appropriate attributes and clients
that seek, locate and use such services.
* Transaction--A service that uses the transaction paradigm, used by
commercial applications to concurrently access shared data and to
protect data in centralized databases, together with the distributed
object paradigm to provide the capability of developing reliable,
transaction-based distributed applications typical of commercial
environments. Available on HP-UX.
Security API
The security API allows developers to move forward the development of
secure applications. The security service APIs included are Credentials,
Current, Principal Authenticator, and Invocation Policy. These API's allow
developers to begin the process of securing their applications. The login
name is passed as the credentials; No authentication or encryption is
performed. (The full implementation of CORBA Services Security is planned
for an upcoming release of ORB Plus.)
HP CORBAConnect
HP CORBAConnect extends HP ORB Plus so developers have access to CORBA
objects from OLE Automation, COM and OCX applications as if the objects
were native OLE Automation, COM or OCX objects. Similarly, developers can
write CORBA objects that use the services of OLE Automation, COM and OCX
objects but they appear to developers as if they were CORBA objects.
HP CORBAConnect gives developers:
* A Service Editor, a GUI development and administration tool that lets
developers browse for foreign objects, and configure objects and
interfaces for local or foreign use.
* An underlying bridge for bi-directional development- and run-time
messaging between objects in Microsoft's OLE Automation, COM and OCX
object systems and those in HP ORB Plus.
HP CORBAConnect supports bi-directional messaging. This means that
developers can communicate easily from any of these object systems to any
of the other object systems, and pass objects as arguments to methods where
the client and server are in different object systems.
HP CORBAConnect is available with the Windows NT and Windows 95 versions of
HP ORB Plus. Note that HP ORB Plus does not require that developers use HP
CORBAConnect; developers can write CORBA clients in C++ that run on Windows
NT and Windows 95 machines and access HP ORB Plus directly.
HP Enterprise Wizards
HP Enterprise Wizards are a family of development tools that operate in
Microsoft's Developer Studio. The family consists of Server Wizards and
Insertion Wizards.
Server Wizards are used to create HP ORB Plus servers for both Win32 (NT
and 95) and HP-UX platforms by generating source files and makefiles.
Insertion Wizards are intended to be used with the Server Wizards to add
CORBAservices-life cycle, naming, events-to the HP ORB Plus servers. They
can also be used to create CORBA environment and ORB init variables, and
for modifying the data dictionary.
Easy on CORBA Beginners
Those developing in C++ environments will appreciate HP ORB Plus 2.5.
Application development using HP ORB Plus 2.5 is based on standard C++
programming and does not require any specific software development tool or
application development environment. For example, a developer can use
familiar C++ programming tools and environments like HP Softbench in the
HP-UX environment.
In addition, HP ORB Plus 2.5 includes a set of sample applications
demonstrating a broad range of features. The developer is walked through a
series of applications covering basic CORBA programming through more
advanced topics covering the CORBAservices.
New programmers can thus follow a gradual learning curve in understanding
this new technology. Programmers can progress at their own pace to the more
advanced sample applications. Since they are already familiar with the core
of the application, they can readily identify and assimilate new concepts
and code. The developer can access online help that explains the sample
applications.
Those developing with Developer Studio will appreciate the HP Enterprise
Wizards included with HP ORB Plus 2.5. A wizard is a special form of user
assistance that automates a task through a dialog with the user. They are
especially useful for complex or infrequent tasks that the user may have
difficulty learning or doing. HP Enterprise Wizards blend seamlessly into
the Developer Studio wizard environment to maximize developer productivity
even for those new to CORBA.
Online Documentation
Developers can use a web browser like Mosaic or Netscape to view the online
documentation, moving to new topics by clicking a mouse button on the
hyperlinked text. The browser then provides a display associated with that
topic. For more information on how the developer's browser works, see the
online help provided with the browser. The HP ORB Plus 2.5 online
documentation files are available for viewing here.
Developers can browse through a set of separate Windows-style help files
for HP CORBAConnect and HP Enterprise Wizards available with the Windows NT
and 95 versions of HP ORB Plus 2.5.
Enterprise Solutions
As a pioneer in UNIX-NT interoperability and application distribution, HP
is well positioned to help its customers implement environments based on
this technology. As technology continues to evolve, customers want to work
with a vendor with first hand knowledge and skills--along with available,
innovative products--that can bring together a complete solution.
HP believes it is best positioned to help our customers take advantage of
Internet-enabled distributed computing. We provide a wide variety of
distributed computing products, understand how to help our customers adopt
new technology for maximum business benefit, and offer worldwide support
and training programs, ranging from analysis and design to deployment.
---------------------------------------------------------------------------
About CORBA and OMG
The CORBA specifications from the OMG defines a standard way of building an
ORB along with inter-object communication services. An ORB receives
requests for services from client objects, locates the appropriate object
to provide that service (using its object location information), and routes
the relevant requests and responses. HP's distributed-object middleware
offerings allow customers to deploy object-oriented and component-based
applications in distributed computing environments.
An original founder of OMG, HP remains an actively committed supporter of
OMG's work. HP views OMG as central to quickly advancing object technology
standardization efforts. HP continues to help move the CORBA 2.0
specification forward, particularly in the areas of security and
performance.
---------------------------------------------------------------------------
Microsoft and Windows are U.S. registered trademarks of Microsoft
Corporation. Solaris and SunSoft are trademarks of Sun Microsystems, Inc.
---------------------------------------------------------------------------
� 1997 Hewlett-Packard Company Updated February 13, 1997
|
| 29.3 | | SEND::STORM | | Fri Mar 07 1997 10:00 | 15 |
| I may be a little too cynical, but I didn't see any availability
information, like availability dates, prices, how to order, etc,
so I'm not sure they are actually shipping.
The DocObject and ActiveX Control Views are clearly a differentiator
between DTC and HP.
I also believe security is a differentiator. We support full DCE
authentication between a DTC client and an OBB server. There is
no mention of anything like that for HP. In fact, if you read their
security claims closely it's not real clear exactly what they provide
(if anything).
Mark,
|