OOP goes the Paradigm Shift ©
E-mail: jay(at)salsburg(dot)com
Webster defines paradigm as "an outstandingly clear or typical
example or archetype" or in a simpler definition used in the French
language "to show side by side." An acronym of Object Oriented
Programming, OOP is the buzz-word of the computer literate Nineties;
but what is OOP? OOP is 'the use of code structures behaving
with dataflow called a Class that defines a set of Objects
and a set of Operations associated with that Object.'
Object:
Defined in terms of its Attributes.
Operations on a specific Object.
Defined in Methods of Classes.
An Object of a Class is called an Instance of that Class.
An Instance exibits Inheritance and Data Persistence,
organized into Class libraries which allow the programmer to organize
these Classes as Objects in an application.
Object-Oriented Software Development responds to a need - a need for less
confusion, for less repetitious work - and is 'a natural outgrowth of the
human mind's tendency to think in visual metaphors.'
Class:
Defined as a type of Object and a set of Operations associated
with that Object.
The programming environment provides a Class system for constructing
a new Class from an existing Class, by the mechanism of Inheritance.
The new Class (the Subclass) inherits all the Attributes
and Methods of the Parent (its immediate Ancestor). That Parent
may in turn have Inherited Attributes and Methods from
its Parents. The Subclass can have its own additional Attributes
and Methods. A Subclass can only Inherit from one Parent;
this is called Single Inheritance.
Attribute:
A named slot for holding a value.
Two types of Attributes.
Instance Attribute can have a different value for each Instance in
a Class.
Class Attribute has one value for the Class as a whole;
its value is shared by all Instances of the Class.
Persistents:
Have names and hold values even when the application or computer is not
running.
Methods:
Consist of a sequence of one or more Cases.
Similar to functions and proceedures in non-OOP languages.
Two types.
Universal Methods.
Does not belong to to any Class.
Class Methods.
Case:
A Dataflow Diagram of Operations.
Casses of Methods consist of a sequence of one or more Casses.
Operation:
The basic executable component of a Case.
Actually manipulates data.
Consists of a name, zero or more inputs and outputs.
Can operate on input data.
May or may not produce output data.
May produce side effects.
Executes as soon as and only when all inputs have arrived.
The "source code" of an Object, rather to say, the
way in which the Object behaves, called Information Hiding,
also called Encapsulation.
Multiplex:
Operation transformed into a repeating loop of Operations
with a Contol to release the Operation.
Controls:
Attached to Operations.
Activates with success, failure or error of a specific
Operation.
This means that related data and program pieces - the Object's Attributes
and Methods - stored in a kind of Black Box. You ask the Object
to act. You do not need to know how it is done.
Polymorphism:
In general, an interesting phenomenon occurs when the same message is sent
to different Objects. Each Object responds with a Method
appropriate to its Class.
Languages such as Pascal, Ada, and C provide data
types and a way to extend the number of data types. Extensible
data types, structures, and procedures that operate
on the data, characterize these high level languages. In Structured programming,
Top-Down Functional Decomposition (T-DFD) with Data Structures
such as Stacks, Queues, Linked Lists, and Binary
Search Trees allow the programmer to build medium to large programs.
These programming languages and the like develop programs with the functional
aspect of information processing, the how of obtaining a goal. C++
provides "a little" OOP but retains T-DFD. Smalltalk
is somewhat better. But these languages alone do not ensure success in Object
Oriented Development. Adding Abstract Data Types (ADT)
to procedural languages still allow the programmer to fall back into the
T-DFD procedures to solve problems.
This "Backsliding" makes the program less seviceable and reuseable.
The difference between working in a structured language such as C
and using object-oriented development techniques is that in C the
programmer works with a small set of key words and a group of syntax
rules. The programmer's skill consists of being able to combine these
key words and syntax rules to build all kinds of elaborate applications.
In object-oriented development, a large library of Classes
may be instantiated as Objects to do specific things. The
programmer's skill resides in browsing through the Class libraries,
selecting the right Classes and creating out of them the application
- with new Classes that can be added to the library for reuse. This
eliminates the need to write so much repetitious code.
Object Oriented Programs or Applications are made of little independent
"computers" that perform their own computations and interact with
each other by passing messages back and forth. OOP focuses on the
what not the how like proceedural languages. An Object
consists of data and its behavior. An Object "knows" what
actions should be performed when a particular massage command is done or
undone. Conventional languages are locked into static binding of data
types. With OOP, independent "reuseable" objects
may be constructed that perform predictably and hide the data that they
manipulate from the message process. This creates "reuse";
a concept that must be understood to allow management of large programs.
Designers can concentrate more on what pieces of code do, rather than on
how they work internally.
Objects send messages to other Objects, which operate in terms
of "Methods," or well-defined behaviors. The interfaces
between Objects and Object types must be clearly defined.
The main task is to combine these Objects into larger and larger
Objects aimed at the goal of the design. These larger Objects
can then be added to the Class library for reuse. Classes
are potential Objects that become true Objects when they are
instantiated with data for use in an application. Without an enforced discipline
to maintain an object-oriented approach not provided by a language
such as C++, all you have done is change the size of the gun with
which you can shoot yourself in the foot. Procedural languages are
designed to solve problems that are thought out procedurally. When you try
to do an object design off a procedural design it will be inconsistent with
the programmatic interfaces needed to implement correctly the object design.
The paradigm shift to the Object Oriented mind-set and the
functionality contained in class libraries must take hold in the
programmer and in management. Companies that have past success in
software publication using procedural languages, must create an environment
of reuse in the management of large projects. This requires a change
in the organization and the expectations of management. The proper mind-set
does not include solving incongruities by dropping out of object orientation
and writing a procedural fix. Create a new Object with the
view that the new Object will be reuseable. C++ does not demand
object-oriented methods so do not expect a C programmer to
make the transition to OOP by simply purchasing C++. If you
have a big project and the intent is to change from procedural to OOP
you probably will fail at least the first time. The design team should take
a piece of an existing system or one under development and build a version
of it using OOP. This new version probably will be discarded but
it will, over the course of six or more months, help the team shift to the
mind-set of thinking with abstraction.
The idea that C++ equals OOP is about as valid as buying Craftsman
tools at Sears and expecting the tool purchase automatically to repair your
automobile. Skill, practice, experience, mind-set
- these are the pathway of the paradigm shift. The education
establishment will not help. The universities and academic texts offer very
little help for the paradigm shift.
In academic circles, there is still much wariness that Object technology,
which is taking industry by storm, might just be a recent fad that probably
will not last. Academia is threatened by these changes. Their ostrich heads
are buried in hourglass sand that is very quickly running out beneath them.
If you are a software developer planning to hire college graduates that
are OOP savvy, you may not find any. Academics have the erroneous
idea that they can produce graduates in Object technology simply
by translating their text books from Pascal to C++. Changing
the syntax and disregarding the necessity to modify the design approach
is ill-advised.
Instructors do not know enough about object-oriented design to make
a qualified evaluation of proper instructional texts much less write any.
The qualified texts are for professionals who are experienced in state
transition and data-flow diagrams. The courses taught in industry
(not taught in academia) make these courses self important. Recent graduates
in Computer Sciences are OOP naive. When will these courses taught
only in industry become superfluous to the graduate? Typically overwhelmed,
you, the interested reader, wanting immersion in the new Object technology,
need to restart your education. For a few quick tips, search for information
on these key-words:
Ancestor
Arity
Attribute
Case
Computer Aided Software Engineering (CASE)
Class
Class Attribute
Class Identifier
Class Method
Cluster Ordering
Data Cluster
Data Types
Dataflow
Dataflow diagram
Datalink
Encapsulation
Information Hiding
Inheritance
Instance
Method
Object Oriented Database
Object Oriented Programming
Persistents
Polymorphism
E-mail: (select and delete the "no spam")
nospamjay@salsburg.com