Lesson 1

In this Module, we will look deeper into CORBA's core functionality and begin to uncover the details of how things work.
In this module, you will learn:

1. How CORBA clients and CORBA servers function
2. More about the key functionality of the ORB
3. CORBA interfaces and how they tie things together from end to end
4. Where the vendors stand in regards to the CORBA specification

At the end of this module, we will have explored the fundamental structure of CORBA.

CORBA, or Common Object Request Broker Architecture, is a standard for distributed object computing. It allows objects to interact with each other across different languages, platforms, and networks. CORBA's core functionality is provided by the Object Request Broker (ORB). The ORB is a middleware layer that sits between CORBA clients and servers. It is responsible for transmitting requests and responses between the two, as well as managing object references and lifecycles. CORBA also provides a number of other core features, such as: * **Interface Definition Language (IDL):** IDL is a language used to define CORBA interfaces. IDL interfaces are independent of any programming language or platform, which makes them ideal for distributed computing. * **Object references:** CORBA object references are unique identifiers that can be used to locate and access objects remotely. Object references are transparent to clients and servers, meaning that they do not need to know about the underlying implementation details. * **Lifecycles:** CORBA defines a standard lifecycle for objects. This lifecycle includes states such as created, activated, deactivated, and destroyed. The ORB is responsible for managing the lifecycles of CORBA objects. **How CORBA Clients and Servers Function** To use CORBA, a client first needs to obtain an object reference for the server object it wants to interact with. This can be done through a variety of mechanisms, such as a name service or a directory service. Once the client has an object reference, it can invoke methods on the server object as if it were a local object. The ORB will take care of transmitting the request to the server and returning the response to the client. The server object does not need to know anything about the client or the ORB. It simply implements the IDL interface that the client is using to interact with it. CORBA clients and servers can be implemented in a variety of programming languages and on a variety of platforms. This makes CORBA a very versatile and powerful technology for distributed computing. Here is a simple example of how CORBA clients and servers function: 1. The client obtains an object reference for the server object it wants to interact with. 2. The client invokes a method on the server object. 3. The ORB transmits the request to the server. 4. The server object executes the requested method and returns a response. 5. The ORB transmits the response to the client. 6. The client receives the response and processes it. This process is completely transparent to the client and the server. They do not need to know anything about the ORB or the underlying communication mechanisms. CORBA is a powerful technology for distributed computing, and it is used in a wide variety of applications, such as financial trading systems, telecommunications networks, and enterprise resource planning (ERP) systems.

In addition to the CORBA basics of allowing objects to communicate with each other, recall that the OMA (of which CORBA is a part) also provides additional capabilities in the form of CORBAservices and CORBAfacilities. As you'll find out, CORBAservices and CORBAfacilities provide both h horizontal (generally useful to all industries) and vertical (designed for specific industries) services and facilities.