This website is no longer maintained. Its content may be obsolete. Please visit http://home.cern/ for current CERN information.

An Introduction to Object Oriented Technologies

Raúl RAMOS POLLÁN / IT User Support May 23th, 1998

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 meaninful to a few. The aim of this document is to provide a minimun 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 appropiate framework to hold their complexity and flexibility. It is not that the principles biehind CORBA or Java may not have been implemented using 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 appliable 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 drastical 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 offered by Fortran, C, Pascal, etc.) says:

Look

Decompose

organise

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:

Look

Decompose

Organise

If you want to see some examples on how this may work, you may follow the links just below. 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 independant among each other. This is the basic argument on which OO advantages such as reusability and maintainability are based.

For more information:
I strongly recomment 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.

CORBA

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 interoperable 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 interoperate 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.

The ORB
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 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 fitted platform for a specific case.

The difficulty of the tasks that the ORB performs is quite important. 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

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 environment.

Many people identify Java with the Internet because its platform independancy 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 must 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 independancy.

During the short life time of Java, there have been many implementations based on Java. 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:

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 necesary tasks while being able to use the network for other tasks (storage, executing other programs, etc.)
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 JDBC drivers.

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

ActiveX

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 downloaded 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 thought to work only on PCs running Windows OSs. This is an important aspect to have 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].

References

[1] What is object oriented sotfware (http://www.soft-design.com/softinfo/objects.html) by Software Design Consultants.

[2] Object-Oriented Computing - What's the Big Deal? (http://www.firststep.com.au/education/solid_ground/oo.html) By First Step Communications

[3] Object-Oriented really is better than Structured (http://www.cs.uwa.edu.au/teaching/cs220.oop/readings1997/whyoop.html) By the University of Western Australia. This is a general comparison with the structured paradigm and also gives very good criteria to judge OO.

[4] Object Oriented related links. (http://www.uax.es/uax/oop/frames_left.html). 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

[5] The OMG group CORBA for Beginners (http://www.omg.org/news/begin.htm). It contains a variety of links which range in depth and length. Among them I strongly recommend to take a look at:

http://www.omg.org/about/wicorba.htm

http://www.cs.wustl.edu/~schmidt/corba-overview.html

[6] This article is also interesting: When to use CORBA (http://www.javology.com/Javology/AprMay97/IS_CORBA_0497.html).

[7] An overview (http://java.sun.com/docs/overviews/java/java-overview-1.html) of the ideas behind the design of java, from Sun.

[8] Documentation on most of the other issues related to Java (such as the points mentioned above) can be obtained from Javasoft (http://www.javasoft.com/docs).