Common Object Request Broker Architecture

The Common Object Request Broker Architecture is a standard defined by the Object Management Group designed to facilitate the communication of systems that are deployed on diverse platforms. CORBA enables collaboration between systems on different operating systems, programming languages, and computing hardware. CORBA uses an object-oriented model although the systems that use the CORBA do not have to be object-oriented. CORBA is an example of the distributed object paradigm.
While briefly popular in the mid to late 1990s, CORBA's complexity, inconsistency, and high licensing costs have relegated it to being a niche technology.

Overview

CORBA enables communication between software written in different languages and running on different computers. Implementation details from specific operating systems, programming languages, and hardware platforms are all removed from the responsibility of developers who use CORBA. CORBA normalizes the method-call semantics between application objects residing either in the same address-space or in remote address-spaces. Version 1.0 was released in October 1991.
CORBA uses an interface definition language to specify the interfaces that objects present to the outer world. CORBA then specifies a mapping from IDL to a specific implementation language like C++ or Java. Standard mappings exist for Ada, C, C++, C++11, COBOL, Java, Lisp, PL/I, Object Pascal, Python, Ruby, and Smalltalk. Non-standard mappings exist for C#, Erlang, Perl, Tcl, and Visual Basic implemented by object request brokers written for those languages. Versions of IDL have changed significantly with annotations replacing some pragmas.
The CORBA specification dictates there shall be an ORB through which an application would interact with other objects. This is how it is implemented in practice:

The application initializes the ORB, and accesses an internal Object Adapter, which maintains things like reference counting, object instantiation policies, and object lifetime policies.
The Object Adapter is used to register instances of the generated code classes. Generated code classes are the result of compiling the user IDL code, which translates the high-level interface definition into an OS- and language-specific class base for use by the user application. This step is necessary in order to enforce CORBA semantics and provide a clean user process for interfacing with the CORBA infrastructure.

Some IDL mappings are more difficult to use than others. For example, due to the nature of Java, the IDL-Java mapping is rather straightforward and makes usage of CORBA very simple in a Java application. This is also true of the IDL to Python mapping. The C++ mapping requires the programmer to learn datatypes that predate the C++ Standard Template Library. By contrast, the C++11 mapping is easier to use, but requires heavy use of the STL. Since the C language is not object-oriented, the IDL to C mapping requires a C programmer to manually emulate object-oriented features.
In order to build a system that uses or implements a CORBA-based distributed object interface, a developer must either obtain or write the IDL code that defines the object-oriented interface to the logic the system will use or implement. Typically, an ORB implementation includes a tool called an IDL compiler that translates the IDL interface into the target language for use in that part of the system. A traditional compiler then compiles the generated code to create the linkable-object files for use in the application. This diagram illustrates how the generated code is used within the CORBA infrastructure:
This figure illustrates the high-level paradigm for remote interprocess communications using CORBA. The CORBA specification further addresses data typing, exceptions, network protocols, communication timeouts, etc. For example: Normally the server side has the Portable Object Adapter that redirects calls either to the local servants or to the other servers. The CORBA specification leaves various aspects of distributed system to the application to define including object lifetimes, redundancy/fail-over, memory management, dynamic load balancing, and application-oriented models such as the separation between display/data/control semantics, etc.
In addition to providing users with a language and a platform-neutral remote procedure call specification, CORBA defines commonly needed services such as transactions and security, events, time, and other domain-specific interface models.

Versions history

This table presents the history of CORBA standard versions.

Version	Version Date	Highlights	Corba IDL Version
1.0	October 1991	First version, C mapping
1.1	February 1992	Interoperability, C++ mapping
1.2	December 1993
2.0	August 1996	First major update of the standard, also dubbed CORBA 2
2.1	August 1997
2.2	February 1998	Java mapping
2.3	June 1999
2.4	August 2000
2.5	September 2001
2.6	December 2001
3.0	July 2002	Second major update of the standard, also dubbed CORBA 3 CORBA Component Model
3.0.1	November 2002
3.0.2	December 2002
3.0.3	March 2004
3.1	January 2008
3.1.1	August 2011	Adopted as 2012 edition of ISO/IEC 19500
3.2	November 2011
3.3	November 2012	Addition of ZIOP
3.4	February 2021	Annotations	4.2

Note that IDL changes have progressed with annotations replacing some pragmas.

Servants

A servant is the invocation target containing methods for handling the remote method invocations. In the newer CORBA versions, the remote object is split into the object and servant . It can be one servant per remote object, or the same servant can support several objects, associated with the given Portable Object Adapter. The servant for each object can be set or found "once and forever" or dynamically chosen each time the method on that object is invoked. Both servant locator and servant activator can forward the calls to another server. In total, this system provides a very powerful means to balance the load, distributing requests between several machines. In the object-oriented languages, both remote object and its servant are objects from the viewpoint of the object-oriented programming.
Incarnation is the act of associating a servant with a CORBA object so that it may service requests. Incarnation provides a concrete servant form for the virtual CORBA object. Activation and deactivation refer only to CORBA objects, while the terms incarnation and etherealization refer to servants. However, the lifetimes of objects and servants are independent. You always incarnate a servant before calling activate_object, but the reverse is also possible, create_reference activates an object without incarnating a servant, and servant incarnation is later done on demand with a Servant Manager.
The is the CORBA object responsible for splitting the server side remote invocation handler into the remote object and its servant. The object is exposed for the remote invocations, while the servant contains the methods that are actually handling the requests. The servant for each object can be chosen either statically or dynamically, in both cases allowing the call forwarding to another server.
On the server side, the POAs form a tree-like structure, where each POA is responsible for one or more objects being served. The branches of this tree can be independently activated/deactivated, have the different code for the servant location or activation and the different request handling policies.

Features

The following describes some of the most significant ways that CORBA can be used to facilitate communication among distributed objects.

Data By Value

The CORBA Interface Definition Language provides the language- and OS-neutral inter-object communication definition. CORBA Objects are passed by reference, while data are passed by value. The combination of Objects-by-reference and data-by-value provides the means to enforce great data typing while compiling clients and servers, yet preserve the flexibility inherent in the CORBA problem-space.

Objects By Value (OBV)

Apart from remote objects, the CORBA and RMI-IIOP define the concept of the OBV and Valuetypes. The code inside the methods of Valuetype objects is executed locally by default. If the OBV has been received from the remote side, the needed code must be either a priori known for both sides or dynamically downloaded from the sender. To make this possible, the record, defining OBV, contains the Code Base that is a space-separated list of URLs whence this code should be downloaded. The OBV can also have the remote methods.

CORBA Component Model (CCM)

CORBA Component Model is an addition to the family of CORBA definitions. It was introduced with CORBA 3 and it describes a standard application framework for CORBA components. Though not dependent on "language dependent Enterprise Java Beans ", it is a more general form of EJB, providing four component types instead of the two that EJB defines. It provides an abstraction of entities that can provide and accept services through well-defined named interfaces called ports.
The CCM has a component container, where software components can be deployed. The container offers a set of services that the components can use. These services include notification, authentication, persistence, and transaction processing. These are the most-used services any distributed system requires, and, by moving the implementation of these services from the software components to the component container, the complexity of the components is dramatically reduced.