The Common Object Request Broker Architecture (CORBA) is a specification

developed by the Object Management Group (OMG). CORBA describes a messaging

mechanism by which objects distributed over a network can communicate with each
other irrespective of the platform and language used to develop those objects.
There are two basic types of objects in CORBA. The object that includes some
functionality and may be used by other objects is called a service provider. The object
that requires the services of other objects is called the client. The service provider
object and client object communicate with each other independent of the programming
language used to design them and independent of the operating system in which they
run. Each service provider defines an interface, which provides a description of the
services provided by the client.

Techopedia explains Common Object Request Broker Architecture (CORBA)

CORBA enables separate pieces of software written in different languages and running
on different computers to work with each other like a single application or set of
services. More specifically, CORBA is a mechanism in software for normalizing the
method-call semantics between application objects residing either in the same address
space (application) or remote address space (same host, or remote host on a network).
CORBA applications are composed of objects that combine data and functions that
represent something in the real world. Each object has multiple instances, and each
instance is associated with a particular client request. For example, a bank teller object
has multiple instances, each of which is specific to an individual customer. Each object
indicates all the services it provides, the input essential for each service and the output
of a service, if any, in the form of a file in a language known as the Interface Definition
Language (IDL). The client object that is seeking to access a specific operation on the
object uses the IDL file to see the available services and marshal the arguments
appropriately.
The CORBA specification dictates that there will be an object request broker (ORB)
through which an application interacts with other objects. In practice, the application
simply initializes the ORB, and accesses an internal object adapter, which maintains
things like reference counting, object (and reference) 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 to be applied 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.