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

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

 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.

 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.

 Have names and hold values even when the application or computer is not running.

 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.

 A Dataflow Diagram of Operations.
 Casses of Methods consist of a sequence of one or more Casses.

 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.

 Operation transformed into a repeating loop of Operations with a Contol to release the Operation.

 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.

 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:

Computer Aided Software Engineering (CASE)
Class Attribute
Class Identifier
Class Method
Cluster Ordering
Data Cluster
Data Types
Dataflow diagram
Information Hiding
Object Oriented Database
Object Oriented Programming

E-mail: (select and delete the "no spam")