This website is no longer maintained. Its content may be obsolete. Please visit http://home.cern/ for current CERN information.
Next: User Documentation
Previous: Forthcoming IT Tutorial Programme in 1998
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
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.
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.
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.
(2) Decompose your domain into functions, which will be implementing
(3) Then, organise your functions so that they can call
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
(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
- they interact among each other
by sending messages that may trigger actions on the object to which they
- they are defined in a hierarchical way so that objects in lower
levels inherit automatically all properties and behaviour of the objects
in upper levels;
- objects in lower levels may add or modify the properties
or behaviour that they have inherited.
For more information:
I strongly recommend to take a look at references
 through .
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
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
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,
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.
(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
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 , and some interesting stuff
Java is an object oriented (OO), platformindependent, multithreaded,
dynamic, generalpurpose programming environment based loosely on C++.
Java "compilers" take Java source code and generate "executables" consisting
of machineindependent 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
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:
JavaBeans: A software component model written in Java. Any Java
object which adheres to certain property and behaviour conventions can
be a Bean. Then, development tools may exploit this fact. For instance,
if a custom graphical object (such as a HEP event display) follows the
JavaBeans conventions, it can be included in some other application by
just drag&dropping using a graphical development tool which understands
also the JavaBeans conventions.
Java RMI: Java Remote Method Invocation (RMI) allows programmers
to write distributed objects using Java. RMI provides a simple and direct
model for distributed computation with Java objects. These objects can
be new Java objects, or can be simple Java wrappers around an existing
API. Its principles are, in essence, the same as CORBA's, but much less
pretentious. In fact, it can be seen as a Java specific implementation
of the main CORBA ideas.
JavaOS: Is a small and efficient operating environment that executes
Java applications directly on hardware platforms without requiring a host
operating system. The goal of JavaOS is to enable the development of secure,
high performance and highly robust network devices built on multiple hardware
platforms in heterogeneous, distributed networks. Network devices are capable
of executing programs locally even though they are inherently network oriented.
This allows them to carry out locally the necessary tasks while being able
to use the network for other tasks (storage, executing other programs,
JDBC: Java Database Connectivity. Just as ODBC provides a standard
interface to access a variety of databases from Windows programs, JDBC
provides a uniform interface to access various databases from Java programs.
When writing a Java application that must access a certain database, it
only has to comply with the access method required by JDBC. Then JDBC takes
care of how that specific database is accessed. This way, if the database
is changed (for instance from Postgress to Oracle) Java programs accessing
it need not be changed. The most widely use database systems already provide
See references  and .
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
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 .
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:
collection of resources at University Alfonso X El Sabio, in Spain. Very
well structured and complete for people with different base knowledge or
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.
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: User Documentation
Previous: Forthcoming IT Tutorial Programme in 1998