If we trace our steps down the spiraling routes of software history, searching for the origin of the object oriented programming, we will notice that it was back in 1967 that the first object-oriented ideas emerged. The advent of these new concepts took place in the context of the language Simula67, which was created in order to satisfy the growing need that the scientific community was experiencing with regard to a language for a simulation modeling. However, a gradual evolution, which spanned more than 20 years, could be observed before the new object oriented approach became widely applied. Ever since its origin about four decades ago, the object technologies have been gradually replacing the classical software development approaches, and it was in the 90-ies, that object-oriented software engineering turned into the paradigm of choice for the majority of software builders. Naturally, the question concerning the reason for this gradual transition to object-oriented technologies is to arise and there is still no clear-cut answer to it. Some people simply speculate that most software professionals crave for novelties in the software engineering arena,

Inheritance offers some previewing possibilities. Subclasses can be used to factor out alternatives for testing purposes. For example, if a class is to be encoded with a particular user interface, alternative interfaces can be factored into subclasses during the design phase of the project. Each alternative can then be demonstrated to potential users to see which they prefer. When the choice is made, the selected subclass can be reintegrated into its super class.

An abstract data type is the description of the object type, i.e. it has no implementation details. Creating abstract data types (classes) is a fundamental concept in object-oriented programming. We call them abstract because we try to identify and use only those characteristics, which are pertinent to your present purpose. Abstract data types work almost exactly like built-in types: You can create variables of a type (called objects or instances in object-oriented parlance) and manipulate those variables (called sending messages or requests; you send a message and the object figures out what to do with it). Once a class is established, you can make as many objects of that class as you like, and then manipulate those objects as if they are the elements that exist in the problem you are trying to solve. Indeed, one of the challenges of object-oriented programming is to create a one-to-one mapping between the elements in the problem space and objects in the solution space.

Using inheritance is one of the ways of offering reusability, extensibility, and lower cost. It also provides a means for relating classes in a semantically sound way. It seems a pity, however, to go to all the trouble to create a class and then be forced to create a brand new one that might have similar functionality. It is much nicer if we can take the existing class, clone it, and then make additions and modifications to the clone. This is effectively what you get with inheritance, with the exception that if the original class (called the base or super or parent class) is changed, the modified "clone" (called the derived or inherited or sub or child class) also reflects those changes. Since changes to data and operations contained within a super class is immediately inherited by all subclasses that have inherited from the super class, the class hierarchy becomes a great mechanism through which changes can be instantaneously propagated through the system.

The class interface establishes what requests you can make for a particular object. However, there must be code somewhere to satisfy that request. This, along with the hidden data, comprises the implementation. From a procedural programming standpoint, it's not that complicated. A type has a function associated with each possible request, and when you make a particular request to an object, that function is called.

3. Pros of the Object-Oriented approach on the Software Engineering arena

Information hiding, also known as encapsulation is one of the major cornerstones in the object-oriented software development and good software engineers do their best to enforce it in the software process. It relates to the idea of localizing things, protecting them from interactions with the environment. Encapsulation keeps the implementation of an object out of its interface. The idea is to make the capsule as tight as possible so that the interface is as small as possible. In this way you know that if you alter a variable in one part of the program, the only effect it is going to have is on anything where information has been traded across that very small and well-defined interface.

Now let's try pinpoint some of the advantages that the object-oriented paradigm can offer in the software development process, in terms of software engineering goals, such as correctness, robustness, extensibility, reusability, integrity etc.

At one time in programming history, the question of how much memory a program would use was settled when the source code

Some common words found in the essay are:
Engineering Approach, Dataflow Diagrams, Inheritance Using, Software Engineering, Polymorphism Polymorphism, Classes Objects, Objects Functions, Fortran BASIC, Dynamic Loading, Encapsulation Information, object-oriented programming, software engineering, base class, object oriented, super class, object-oriented software, software development, object-oriented software engineering, abstract data, derived class, data types, abstract data types, object oriented programming, derived class type, class super class,
Approximate Word count = 7164
Approximate Pages = 29 (250 words per page double spaced)