CERN Accelerating science

This website is no longer maintained. Its content may be obsolete. Please visit for current CERN information.

next up previous
Next: User Documentation Up: cnl231.html Previous: Forthcoming IT Tutorial Programme in 1998

An Introduction to Object Oriented Technologies

  Raúl Ramos Pollán IT/User Support

Many emerging OO based technologies are becoming increasingly more important, up to the point of gradually building the foundations for the activities of the Information Technology areas. These technologies have brought with them a new terminology (CORBA, Java, ActiveX, etc.) familiar to many but meaningful to a few. The aim of this document is to provide a minimum insight into them.

Object Orientation 

OO is the heart
OO is a must to anyone trying to understand these new technologies. In fact, it is the Object Oriented paradigm which provides the most appropriate framework to hold their complexity and flexibility. The principles behind CORBA or Java could have been implemented using some other paradigm, but probably their applicability would have been much more limited.

Thinking OO
OO is not just another syntax for programming. It is a complete new way of facing problems and implementing them. OO principles are applicable to almost all phases in the Software Development processes. You can make your analysis, design and implementation following the OO principles. It is not always easy to change one's mind in such a drastic way. It might take some time before assimilating its concepts and thus, to fully appreciate what OO is.

Paradigms. OO vs. Functional
Think about what you do when you face a problem. This is, when you have to model a part of the world and transfer that model into a physical device (a computer) which will be integrated in some environment. Usually this is a three step process. First you make an abstraction of the world: you take the characteristics of the world which are interesting to you and forget about what you don't consider important. Then you make a decomposition of the world: you divide it up into smaller more manageable parts. And finally, you organise those parts under a certain structure so that when they work together they do what they are supposed to do.

Each step can be done following very different criteria. A (programming) paradigm is just a set of rules and principles to carry out these three steps. For instance, the functional paradigm (which is the one offered by Fortran, C, Pascal, etc.) says:

    (1) Look at your problem in terms of actions or tasks to carry out.
    (2) Decompose your domain into functions, which will be implementing those tasks.
    (3) Then, organise your functions so that they can call each other.
Then, the different languages follow these principles. They may call things a little different (functions are offered referred to as subroutines, procedures, subprograms, etc.) and they may offer different ways of storing your functions (by using libraries, repositories, etc.) but the important idea is that they all follow the above principles. The functional paradigm is often referred to as the structured or algorithmic paradigm. Much of the power of a paradigm relies on few aspects of its principles, such as the convenience of the the elements into which you divide your problem, the complexity that you can build up by using the organisational principles, how you can handle this complexity when you change the model, etc. You can consider a paradigm as instructions to build bricks (abstraction and decomposition) plus instructions to make buildings from those bricks (organisation). The complexity and characteristics of your buildings will depend on the quality of your bricks and of the architecture.

Now, the OO paradigm says:

    (1) Look at your problem in terms of individual, independent objects.
    (2) Decompose your domain into objects. Each object has some certain properties and a certain behaviour or set of actions particular to each object.
    (3) Organise your objects so that
By now, try to compare the principles of the functional and OO paradigms. OO has a richer set of principles. Now think about the kind of buildings that you can build following such principles. OO principles let you build richer and more complex structures with reasonable maintainability costs and still keep objects independent among each other. This is the basic argument on which OO advantages such as re-usability and maintainability are based.

For more information:
I strongly recommend to take a look at references [1] through [4]. They are short, precise and include a couple of examples which will help you fix the abstract ideas I've talked about. The first two links are very simple examples.



The Common Object Request Broker Architecture (CORBA) is an industry consensus standard that defines a higher level facility for distributed computing; this standard is described by the Object Management Group (OMG), an industry consortium whose mission is to define a set of interfaces for inter-operable software.  CORBA simplifies distributed environment system software in several ways. The distributed environment is defined using an object-oriented paradigm that hides all differences between programming languages, operating systems and object location. CORBA's object-oriented approach enables diverse types of implementations to inter-operate at the same level, hiding idiosyncrasies and supporting reuse.

CORBA defines a message bus between objects (probably residing on different machines and built under different languages and OSs) that conveys operation invocation requests from clients to object implementations and their results on the way back, no matter what the object environments (language, location or platform) are. How CORBA does its work is of no concern for both the client and the remote object. CORBA provides the mechanisms for messages to be transported between objects and it requires the objects to talk in CORBA.

At the heart of CORBA is the Object Request Broker, which provides the mechanisms and transparency for sending messages among objects regardless on where they are. A client object uses the ORB to obtain a service from a server object, giving to the ORB the request and its parameters. According to the way the request was made, the client object can either wait for the result of the call or do whatever it needs before accepting and computing the return value. The ORB is thus in charge and works to

    (1) locate the object that will implement the request,
    (2) activate it if it is not already running, passes the parameters to it,
    (3) pull for the result, and
    (4) provide the client with it, or with an exception if something unexpected occurred.
Besides the signature (name, arguments and return type) of the method it invokes, an object reference and its type, the client doesn't need to know anything specific about the client: no information about programming language, protocol, implementation or operating system is needed. This provides the freedom to implement the functionality of an object in the best way and on the more suitable platform for a specific case.

The difficulty of the tasks that the ORB performs is considerable. Once an object can talk CORBA it will see all other objects which also talk CORBA in the same way. This is a great advantage towards the development of distributed applications and architectures.

In order to do this, CORBA defines many other concepts and terms, which you will find in the links.

For more information:
Quick introductions can be found at [5], and some interesting stuff in [6].



Java is an object oriented (OO), platform­independent, multi­threaded, dynamic, general­purpose programming environment based loosely on C++. Java "compilers" take Java source code and generate "executables" consisting of machine­independent bytecodes. One of the design goals of Java was to achieve platform independence- the ability to execute the same code on a variety of platforms.

Java accomplishes platform independence beyond the source level. A Java "compiler" creates platform-independent bytecodes. Bytecodes are binary files that can be executed on other platforms without having to compile the source for each target platform. These bytecodes are a set of instructions that look somewhat like machine code, but are not specific to a particular CPU.  Java programs can be "executed" on any machine offering a bytecode interpreter or Java Virtual Machine. These "executables" can run unmodified on any platform that supports the Java runtime environment. The runtime environment beyond the Java Virtual Machine also includes a set of base classes which define how the program interacts with the native machine's environment.

Many people identify Java with the Internet because its platform independency makes it ideal for deploying applications without worrying about the kind of machine on which it runs. This way, WWW browsers may contain a Java interpreter, obtain Java bytecode from somewhere in the net and execute it. Due to bandwidth reasons, Java applications designed for running on a WWW server (Applets) are usually small and perform minor tasks. However, this Internet affinity should not hide the fact that Java is a full object oriented programming language able to run complex and large applications. Java provides a clean and easy-to-learn language with full platform independency.

During the short life time of Java, there have been many implementations based on it. Sun is making a great effort to make Java the choice of many people. They and others have developed many Java utilities, libraries and projects which make Java quite attractive and time saving for many people. Some of these projects are:

For more information:
See references [7] and [8].


ActiveX is a technology designed to bring a greater level of interactivity and flexibility to Web sites and standalone applications. Based on Microsoft's object-oriented COM (Component Object Model) standard, ActiveX technology consists of two types of components: ActiveX controls and Active documents.

ActiveX controls are small, self-contained modules of code that work within Web pages and are designed to add functionality to them. From the user's perspective, controls work in a similar way to plug-ins, except that they load dynamically; in other words, when the user visits a site that contains an ActiveX control, the control is down-loaded automatically. Active documents enable users to view non-HTML documents, such as Microsoft Excel or Word files, through a Web browser. From their design, they were intended to work only on PCs running Windows OSs. This is an important fact to keep in mind, considering that users with non-Windows platforms won't be able to view sites relying on ActiveX controls.

ActiveX controls can be created in Visual Basic 5.0 or C++; however, most Web developers will probably want to utilize existing controls instead of creating new ones from scratch. Microsoft's Control Pad is designed to provide developers with an easy way to create ActiveX controls using existing components.

ActiveX vs. Java
ActiveX is considered to be a complement to Java; they are not competitive technologies. In fact, ActiveX can be used side by side with Java. Java is essentially a programming language, and ActiveX can enhance this language by enabling it to access code written in any other language. This gives Web designers the flexibility to include multiple objects in a page (some built in Java, some in other languages) —and have them communicate interactively However, since Java applets and ActiveX controls can perform some of the same functions, there is some overlap. Due to the market wars, Netscape browsers do not run ActiveX controls. Also, as mentioned before, they are designed for the Windows world, which makes their portability quite limited.

For more information:
The above information was taken from [9]



What is Object-Oriented Software? By Software Design Consultants.
Object-Oriented Computing - What's the Big Deal?  By First Step Communications.
Object-Oriented really is better than Structured By the University of Western Australia.
This is a general comparison with the structured paradigm and also gives very good criteria to judge OO.
Object Oriented 8757 Links: an OO collection of resources at University Alfonso X El Sabio, in Spain. Very well structured and complete for people with different base knowledge or backgrounds
The OMG group CORBA for Beginners page contains a variety of links which range in depth and length. Among them I strongly recommend to take a look at:
The article "When to use CORBA" is also interesting.
An overview of the ideas behind the design of Java, from Sun.
Documentation on most of the other issues related to Java (such as the points mentioned above) can be obtained from Javasoft.
The ActiveX documentation centre.

next up previous
Next: User Documentation Up: cnl231.html Previous: Forthcoming IT Tutorial Programme in 1998