Corba Fundamentals   «Prev  Next»
Lesson 1

CORBA Fundamentals Preamble

In this module you will explore the basic building blocks of CORBA and how they fit together. CORBA offers many capabilities, but most of them build on lower levels where possible. The things we are about to explore represent those fundamental layers.
In this module, you will be introduced to:
  1. The technologies that led to CORBA
  2. CORBA clients & servers
  3. CORBA requests & replies
  4. The Object Management Architecture (OMA)

The development of "CORBA (Common Object Request Broker Architecture)"" was influenced by several predecessor technologies and concepts. These technologies laid the groundwork for distributed systems, remote communication, and object-oriented programming. Here are the key predecessors:
  1. Remote Procedure Call (RPC)
    • Description: RPC is a protocol that allows a program to execute code on a remote server as if it were a local procedure.
    • Contribution: RPC introduced the idea of abstracting the complexities of network communication, which became a foundational concept for CORBA’s remote method invocation (RMI).
  2. Distributed Computing Environment (DCE)
    • Description: DCE, developed by the Open Software Foundation (OSF), provided a framework for developing distributed applications, including RPC, directory services, and security services.
    • Contribution: DCE offered a practical implementation of RPC and other distributed computing tools, demonstrating the feasibility of standardizing such systems. CORBA built upon this idea to create a more object-oriented and platform-agnostic system.
  3. Object-Oriented Programming (OOP)
    • Description: OOP languages like C++, Smalltalk, and later Java emphasized encapsulation, inheritance, and polymorphism.
    • Contribution: The object-oriented approach influenced CORBA's design, enabling the modeling of systems as interacting objects with defined interfaces.
  4. Inter-Process Communication (IPC)
    • Description: Mechanisms such as message passing, shared memory, and socket communication enabled processes to exchange data.
    • Contribution: CORBA abstracted these lower-level communication mechanisms to create a seamless, high-level interface for remote object interactions.
  5. Message-Oriented Middleware (MOM)
    • Description: MOM technologies, such as IBM’s MQSeries, facilitated asynchronous communication between distributed components.
    • Contribution: CORBA incorporated some concepts from MOM, including reliable message exchange and decoupling of systems.
  6. Network Communication Protocols
    • Description: Protocols like TCP/IP and HTTP provided the underlying network infrastructure for communication.
    • Contribution: CORBA's Object Request Broker (ORB) leveraged these protocols to facilitate communication between distributed components.
  7. Distributed Object Management Systems (DOMS)
    • Description: Early systems such as the Xerox Network Systems (XNS) and Apollo’s Network Computing System (NCS) supported distributed object management.
    • Contribution: These systems influenced CORBA’s architecture by providing examples of distributed object management and interaction.
  8. Standardization Efforts
    • ISO/OSI Model: Provided a framework for developing interoperable communication systems.
    • Contribution: CORBA aligned with the need for interoperability across different platforms, operating systems, and languages.
  9. Early Object-Oriented Databases (OODBs)
    • Description: Databases such as ObjectStore and GemStone supported the storage and manipulation of objects.
    • Contribution: These systems introduced the notion of object persistence, which CORBA adopted to manage distributed objects.
  10. Mach Microkernel
    • Description: Mach, a pioneering microkernel, supported distributed system features and interprocess communication.
    • Contribution: Mach's ability to enable distributed object communication inspired similar capabilities in CORBA.

CORBA’s development by the **Object Management Group (OMG)** in 1991 synthesized these technologies and ideas into a unified standard for distributed, object-oriented systems. This allowed developers to create platform-independent, language-neutral distributed applications.

Distributed Applications

CORBA products provide a framework for the development and execution of distributed applications.
Distributed applications introduce a whole new set of difficult issues. Sometimes there is no alternative since some applications are distributed across multiple computers because of one or more of the following reasons:
  1. The data used by the application are distributed
  2. The computation is distributed
  3. The users of the application are distributed

Corba Fundamentals
CORBA (Common Object Request Broker Architecture) CORBA (Common Object Request Broker Architecture) is now well established in the mainstream of software development and has found phenomenal industry acceptance. CORBA is supported on almost every combination of hardware and operating system in existence and
  1. is available from a large number of vendors,
  2. supports a large number of programming languages, and
  3. is now being used to create mission-critical applications in industries as diverse as health care, telecommunications, banking, and manufacturing.
The increasing popularity of CORBA has created a corresponding increase in demand for software engineers who are competent in the technology. Naturally, CORBA has had to evolve and grow (sometimes painfully) to reach its current levels of popularity and deployment. When the first version of CORBA was published in 1991, it specified how to use it only in C programs. This was a result of building CORBA from proven technology. At that time, most production-quality distributed systems were written in C.
By 1991, object-oriented (OO) languages such as Smalltalk, C++, and Eiffel had been in use for years. Not surprisingly, many developers thought it strange that a languageindependent distributed OO system such as CORBA could be programmed only using C, a non-OO, procedural language. To correct this short-coming, several development groups at companies such as Hewlett-Packard, Sun Microsystems, HyperDesk Corporation, and IONA Technologies started developing their own proprietary mappings of CORBA to the C++ language. These proprietary mappings of CORBA to C++, all invented independently, differed in many ways. As most C++ programmers know, C++ is a multiparadigm language that supports varied approaches to application development, including structured programming, data abstraction, OO programming, and generic programming. The proprietary C++ mappings reflected this diversity; each of them mapped different CORBA data types and interfaces into different (sometimes very different) C++ types and classes. The mapping differences reflected not only the varied backgrounds of the developers but also the ways they intended to use CORBA to build systems as diverse as software integration middleware, operating systems, and even desktop tool kits.

SEMrush Software