OBJECT-ORIENTED PROGRAMMING

Object-oriented programming (OOP) focuses on grouping, simplification, streamlining, and standardization. For example, it would seem unreasonable if every time someone traveled between two cities that they would experiment and do it by trial and error. A more reasonable methodology would be to develop maps and identify a standardized shortest route to travel, thereby simplifying the traveling process. However, this type of simplification has not always been obvious and even today we find many instances where it is not used. For example, in manufacturing there are numerous instances in which the same exact part was designed from scratch several times. It has separate drawings, separate part numbers, and is stored in separate places. Until recently, no grouping methodology existed to identify opportunities for part standardization. The grouping process that was finally developed is called group technology and comes from Russia. However, most manufacturers still do not use the technique.

OOP can be found in the modularization and interchangeability of computer hardware. You can open the box of almost any personal computer (PC) and interchangeably replace storage drives, memory, peripherals, and so on. This standardization was driven by competition and by the speed at which the technology has changed, but it has significantly simplified and streamlined the computer hardware updating and servicing process.

OOP has also made its way into management practices. For example, the implementation of change is always traumatic. One of the reasons for this is that no one seems to have a standard, objective measure for the success of the change process. By utilizing tools such as total quality management (TQM) for the standardization of the change process, which incorporates systematic problem solving (SPS), the implementation process becomes grouped and streamlined so that anyone can review the status of a change process.

The term object-oriented programming originally comes from the systems development and computer programming world. After years of programming and systems development, someone realized that there are many repetitive functions. For example, file adds, changes, and deletes occur frequently and during multiple processes. It would seam reasonable that one add-change-delete routine could be developed in a modular form that could be accessed any time an add-change-delete process needed to occur. Developers grouped these functions into accessible and executable modules that became known as objects. Developing programs using objects became known as object-oriented programming (OOP).

OOP significantly reduced the level of confusion between software developers. For example, when multiple developers were working on the same project, they did not need to thoroughly understand each other's code in order to develop their piece of the project. Similarly, in software maintenance, developers did not need to relearn the previous code in order to make changes. Understanding the OOP modules was sufficient to focus the change appropriately.

The design of the OOP process came partially out of a reaction to the slow development time for computer programs, and partly because of the high demand for computer developers. Using object-oriented programming, fewer people can accomplish more.

Operationally, OOP attempts to lead software development away from the abstract and refocus it on real-world objects. Examples of objects that could be the focus of a programming effort would be a user, display screen, and local-area network (LAN), not bits, bytes, and files. These objects become the focus of OOP programming attention.

In OOP the various properties of an object are analyzed. Understanding the properties assists in developing efficient modules. These properties include:

1. State—the properties of the object that cause a specific reaction to any specific event. For example, a terminal has several states: off; on and running; on and idle; and under maintenance.
2. Behavior—the way an object reacts to interactions from and with other objects. Behavior is determined by the set of operations defined as functional for that object. For example, an invalid entry from the person object is reacted to by an error message by the application package object.
3. Identity—objects are unique, merely because they exist separately. Objects are not grouped with other objects because of similar behavior. Nor can any object have more than one identity or name.
4. Encapsulation—this is where data and functionality are combined. Data and corresponding programs are elements that are isolated together. This prevents the corruption of their internal state.
5. Messaging—objects send messages to each other in order to access each other and to request a response. The object responds back to the requestor based on its defined behavior.
6. Collaboration—objects use each other to accomplish tasks. They share the responsibility for task completion.
7. Information hiding—this is where the activities within the object are hidden from other objects on the outside. This prevents corruption of the object or interference between objects.
8. Inheritance—this is a process of building objects by combining other objects together. By linking one object to another, one often inherits the properties of the other.

We are in an increasingly complex world. Traditionally, systems did not require interaction much beyond the traditional keyboard, screen, user, and disk drive. Now we have massive networks, servers, firewalls, storage units, intranets, e-mail, e-commerce, electronic data interchange (EDI), and so on. OOP reduces the complexity of these massive systems by reducing them into object interactions. OOP offers:

1. Real-world modeling—natural, real-world modularization of systems. We take events and group them into real-world steps that then become objects. We no longer need to deal in the abstractions of computer developers.
2. Large-scaled systems—natural decomposition of real-world problems. We can decompose problems into realistic pieces that make sense.
3. Reusability in the software—software objects can be shared and reused.
4. Iterative development cycles—stages of the development process can be prototyped, allowing for feedback, earlier interaction, and early correction and testing.

OOP has allowed some specific features to be developed that have grown out of the benefits of OOP environment. These include:

1. Graphical user interface (GUI)—the user interface (for example, the screen display) is customizable independent of the software objects.
2. Client/server computing—this allows for the encapsulation of computer information objects, allowing them to be treated as building blocks for both expansion and downsizing.
3. Software reengineering—this allows for the reengineering of some objects while maintaining the integrity and the investment of other objects that do not require change. Entire systems do not need to be altered because a minor change, like a forms change or a new tax law, is enacted. Only the object associated with the change needs to be updated or replaced. Additionally, if pieces of a system become obsolete, they can simply be dropped from the system.

The benefits of OOP include:

• OOP offers usability and reusability of programming code without complete overhaul and replacement.
• OOP has significantly increased the speed of the programming process, both in development and in maintenance.
• OOP offers easier understanding of programming code for co-developers and outsiders trying to understand the code.
• OOP makes it easier to break down complex systems into components and then allows for the prototyping of these systems.
• OOP offers simplified implementation in that basic objects can be independently debugged and do not require as much testing.
• OOP is flexible and highly adaptable to changing business requirements