• inheritance
• encapsulation
• polymorphism
• abstraction

Object Technology
What object technology promotes is the ability to build applications by selecting and assembling objects from libraries. If a developer must create a missing object to meet the application's requirements, that new object may be placed in a library for reuse in future applications. For many simple systems, the developer may use the available objects to form the entire application instead of writing code. More complex development efforts require the developer to modify the objects to meet specific requirements.

Object orientation is much more than a way to program. It can apply across every system development activity, including requirements analysis, design, testing, and business process reengineering. Developing an Object Oriented application requires even more thought about the design than developing in the traditional structured programming environment, because the focus on future reuse requires a longer-term view during analysis and design. However, a well-stocked library of reusable components reduces the need to perform original analysis and design. Nevertheless, many experienced Object Oriented developers know that their application is only as good as its design. Object Oriented analysis and design methodologies and the use of CASE technology are extensive in the Object Oriented world.

Developers must take the good with the bad. Object oriented languages such as C++ is a complex language, and it takes a long time to learn. Developers must first learn C, and then learn the Object Oriented extensions of C++. Moreover, C++ is a low-level language that operates very close to the metal. Developers must learn how to do such things as manage memory directly, access physical disk storage, and use cryptic APIs. The potential for problems is enormous, and it takes about twice as long to develop a client/server application using C++ than it does using other 4GL-driven client/server development environments.

Increased productivity with object technology methods is not just a theory. Organizations that are willing to undertake the learning curve have found tremendous benefits, both in reduced development efforts as well as fewer ongoing maintenance costs.

Inheritance
Developers reuse existing objects through the inheritance mechanism that most object oriented tools provide. Inheritance is a critical concept of object orientation, because it lets developers inherit the capabilities (methods and data) of existing objects. This lets developers maximize the use of application objects.

Some confusion exists about what is inherited in an object hierarchy. In simple terms, data structures and behaviors are the only things that are inherited. Inheritance has nothing to do with the "navigation" of data records.

Developers can implement inheritance in two modes: single and multiple. Single inheritance allows the inheritance of information from a single object/class, whereas multiple inheritance allows objects to inherit information from two objects/classes simultaneously. For example, when using Gupta Corp.'s SQLWindows (which supports multiple inheritance), developers can use data and methods found in two objects, instead of just one. This means that a developer can inherit a file dialog from one object and a set of GUI controls from another, thus creating a new object that combines a file dialog with the GUI controls. Most object oriented tools (Example: Smalltalk) don't support multiple inheritance.

Encapsulation
Encapsulation is one of the features of the object oriented approach that has the most meaning for relational databases. Unlike a traditional relational implementation where data is manipulated by external applications, the object technology approach moves the data access out of external applications and associates them with their base objects. Encapsulation makes the data and methods private within an object. Developers can modify encapsulated data and methods without disturbing other portions of the application, as long as the external interfaces remain unchanged.

Encapsulation has a drawback, however. We must ask ourselves whether it is a good thing that data may only be accessed through predefined behaviors. One of the relational database's primary selling points is the ability to formulate adhoc queries with SQL quickly, independent of data.

Polymorphism
Polymorphism is the ability of different objects to receive the same message and behave in different ways. Polymorphism implies that a standard interface may be created for a related group of objects. The object's specific action will depend on the message passed to the interface. Because the programmer is no longer concerned with the object's internal constructs, we can create some extremely complex programs. Programmers only need to understand the interface to use the object.

Abstraction
Abstraction is defined as the conceptual (not concrete) existence of classes within the database. For example, a database may have a class hierarchy that includes classes that do not have any objects.

Object Oriented Future
Twenty-five years ago, object-oriented development was an interesting concept. Every development tool on the shelf promotes itself as object oriented. Object orientation is a software development success story, and it is here to stay. Despite the tremendous success of objects, developers and development organizations are still low on the object oriented learning curve. In many cases, the tools are far more advanced than the expertise of the developers who use them.

Although most Object Oriented development tools promote object reuse, there is no standard reusable object among tools (for example, C++ objects under Smalltalk). To solve this problem, the Object Management Group (OMG) came up with the Common Object Request Broker Architecture (CORBA)

As the object market expands and component development takes off, more object vendors will be interested in standard objects. IBM, for example, bases its object development on its System Object Model (SOM). Other examples of distributed objects include NeXT Computer's Portable Distributed Objects, and Sun's Distributed Objects Everywhere. Microsoft is pushing OLE and its Component Object Model as its standard object development strategy. Although not object oriented (they do not support inheritance), OLE objects work with a number of application development tools.

It's not a question of whether object oriented development will remain popular, but how to use objects in your application development efforts. There are more choices of object oriented tools out there than ever before. To confuse the issue even more, these tools all implement objects in their own special way. Moreover, the industry is still very much in the learning phase, and it's going to take a few more years before it finally sees the optimal payback from object oriented development.