 |
The 'O Scale' |
| By Clive
Boustred |
A. Introduction
B. The Key Features of Object
Orientation
C. Classification of Products - The "O
Scale"
D. Summary
E. Conclusion
There is much confusion in the
market regarding objects. Objects are now the in thing. Most vendors
claim some form of object-orientated capability in their product.
There are, however, considerable differences between products and
the level to which they support object-orientated concepts. The
problem, however, stems from the basic definition of an object. What
after all is an object?
While this is a relatively
straightforward subject, we will reiterate object concepts in order
to provide clarity and then define a reference model for gauging and
representing a product's object-orientated capabilities.
Firstly, we will ignore the
simplistic view of an object and concentrate entirely on the
software object model. It is, after all, software we are gauging.
Objects are made up of a few
primary elements.
The most fundamental aspect
to object-orientated techniques is the separation of interface
from implementation which involves the support of standard
interfaces being defined for all objects.
Classes form
templates from which similar objects may be created. These
objects being referred to as instances to that
class. Classes may have global class variables and methods
that may be applied to any instance of the class.
The data itself - The
object's state is defined by instance variables.
Methods define procedures
that may be invoked against the variables. The methods define the
behavior of the object.
Sub classing provides the
means by which a new class can inherit instance variables and
methods from any existing class. Inheritance provides the ability
for an object to inherit characteristics from an
ancestor; multiple inheritance refers to many layers of sub
classes.
Different object
methods may be given the same
name. This provides individual procedures for
each object that may be invoked by a common call. For example
invoking the method "Add" could perform different addition
routines for each object. This generally simplifies the design of
programs.
An object's type tells
programmers the set of operations (methods) that can be performed
on the object.
To encapsulate an element
and provide a controlled interface to the outside world,
effectively creating an object out of the encapsulated element
which could be legacy code or an object itself. Encapsulation
provides the ability to modify the contents or methods within an
object without affecting external dependencies, so long as the
interfaces remain constant.
Messages are used to
communicate between objects. Messages might simply invoke methods
on other local or remote objects. Messages may themselves be
objects, containing both methods and variables, that are passed
between different objects.
Object identifiers provide a
unique identifier of the object. Distributed dynamic binding
provides the ability to track and locate objects through their
object identifier, regardless of their physical location.
Reusable objects that come
with or are available for any specific products environment..
Two simple object
classifications have been previously used: Object-Based and
Object-Orientated technologies.
Object-based technologies
represent general technologies that allow the implementation of some
or all of the object principals. However, they do not enforce object
orientation.
Object-orientated technologies
represent technologies that enforce the principals of object
orientation: Inheritance, encapsulation, polymorphism, class
structures, etc. SmallTalk, C++, Ada and most of the ORBs tend to
fall in this category. The lines are not necessarily clear as it is
possible to write a program that is not at all object-orientated
with C++, while OLE, for example, does not support inheritance but
is generally considered an object-orientated technology.
This basic classification
method ends up being too vague for the many products on the market
today. A more detailed classification based on the features of
object orientation is required.
The following section details
the O Scale, which may be used to determine a product's relative
scoring based on key object-orientation features.
The O Scale
To determine a product's
rating on the O Scale, use the following evaluation guidelines for
each of the categories, providing a maximum score of one for each
category.
1. Interface Definition - The
separation of Interface from Implementation
This category forms a
watershed for technologies claiming object orientation, while it
separates proprietary technologies from industry standards. If a
object cannot interact with objects from other vendors and
products it provides a closed proprietary system whose future is
questionable. There are two Interface Definition Language (IDL)
standards: the OMG CORBA IDL and the Microsoft IDL (MIDL).
Firstly, determine if a
product allows the separation of interface from implementation. If
it does not, it is not object orientated. Secondly, determine the
level to which a product supports IDL and MIDL.
2. Classes & Instances
This should be a simple
rating to determine how well the product supports classes &
instances.
3. Instance Variables
In this rating determine the
methods and formats in which instance variables may be stored.
4. Methods
In this rating determine how
easily methods may be implemented.
5. Sub Classes, Inheritance
& Multiple Inheritance
Determine a product's
support of inheritance and its ability to circumvent multiple
inheritance problems.
6. Polymorphism & Object
Type
This should be a simple
rating to determine a product's support for polymorphism. You can
also consider how easily an object's type may be determined.
7. Encapsulation
Determine a product's
ability to encapsulate legacy or foreign elements.
8. Messaging
Determine a product's
messaging capabilities, types of messages that may be transmitted,
performance and message-handling abilities.
9. Object Identifier &
Distributed Dynamic Binding
Consider the way in which
object identifies are issued; if they are guaranteed unique; and
determine the efficiencies and performance of the dynamic binding
techniques.
10. Standard Objects or
Frameworks
One of the key features of
object-orientated technologies is that you may build software from
pre-constructed objects. Determine what frameworks and individual
objects are available. This category will strongly determine which
products succeed of fail in the market.
You should now be able to
determine a product's O Scale rating out of 10 by using the above
classification technique. This will also help separate much of the
marketing hype from a product's real ability to support
object-orientated techniques.
While object orientation
provides considerable advantages one will quickly find that it also
raises new design issues. With polymorphism it is important to
ensure that commonality and consistent naming is applied across all
objects; that the object classes are correctly classified. If the
technology does not eliminate multiple inheritance conflicts,
procedures must be implemented to resolve fragile base class
problem. Object re-use is only effective when the development staff
is fully knowledgeable about what objects are available and how they
may be applied, etc.
Also recognize that there are
numerous different incompatible object models. Objects do not
necessarily speak to each other. CORBA and OLE help to define
standards that promote object interaction.
The goal of any technology is
to enable domain experts to do the things they want to naturally,
without requiring cognitive cycles to be expended on absurd syntax
or inconceivable structure. Note: We used the term "domain expert"
rather than programmer. A programmer has been an unfortunate
necessity for the development of software. As with any software
product, the ideas of the domain expert need to be converted to
machine-driven code. This process has in the past required low-level
programming skills such as the early assembler languages and 3 GLs.
Very rarely do the domain experts themselves possess both domain and
programming skills. Modern CASE tools are striving to make the
program development task intuitive enough for any domain expert to
easily master.
Object-orientated capabilities
provide a strong foundation for implementing advanced distributed
systems. The O Scale will hopefully help you in evaluating and
determining which product suits your organizational and personnel
needs.
Clive
Boustred is featured at DCI's
Software & Client/Server World. | 
