Find your subject
in our database of
Spark your creativity...
an impressive essay!
The Pros and Cons of Object-Oriented Software Engineering
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, but this view is usually targeted as being overly simplistic. The true reasons are therefore usually sought in the number of internal benefits that provide advantage at both the technical and management levels, to which the sweeping Object-Oriented phenomenon naturally leads. In this paper I am trying to pinpoint most of the pros and cons to adopting the object-oriented approach and try to determine why the advantages seem to take the upper hand in the fierce struggle with the disadvantages.
It is natural to begin our discussion of object-oriented software engineering with addressing the term object-oriented and try to dispel any confusion that might arise with respect to notions such as an object, an object-oriented viewpoint, object-oriented methods, etc. For this purpose, however, we need a short preamble in which we will briefly trace the way in which some software abstractions evolved and paved the way for the advent of the next Object-Oriented level of abstraction.
When we come to think of it, we will see that any language can be viewed as an abstraction. For example Assembly language is a small abstraction of the underlying machine. It was in its turn abstracted in many high-level languages, the so-called "imperative" languages such as Fortran, BASIC, and C. These languages were great improvements over Assembly language, but their primary abstraction still required you to think in terms of the structure of the computer rather than the structure of the problem you were trying to solve. The programmer had to establish the association between the machine model (in the "solution space," which was the place where you were modeling that problem, such as a computer) and the model of the problem that was actually being solved (in the "problem space," which was the place where the problem existed). The effort required to perform this mapping, and the fact that it was not inherent to the programming language, produced programs that were difficult to write and expensive to maintain.
The object oriented approach cures most of the ailments of the "imperative" approach by going a step further, providing tools for the programmer to represent elements in the problem space. This representation is general enough so that the programmer is not constrained to any particular type of problem. We refer to the elements in the problem space and their representations in the solution space as "objects." (Of course, you will also need other objects that don't have problem-space analogs.) The idea is that the program is allowed to adapt itself to the lingo of the problem by adding new types of objects, so when you read the code describing the solution, you are reading words that also express the problem. This is a more flexible and powerful language abstraction than what we have had before. Thus, OOP allows you to describe the problem in terms of the problem, rather than in terms of the computer where the solution will run. There's still a connection back to the computer, though. Each object looks quite a bit like a little computer; it has a state, and it has operations that you can ask it to perform. Object-oriented programming is based upon objects, classes, abstract data types, messages, inheritance and polymorphism. In order to understand the merits of the object-oriented programming we need to get acquainted with the main concepts, that constitute the foundation of the object oriented programming.
Functions and data structures are the basic traditional elements of design. Object-oriented programming does not dispute this view of the world but only restructures it at a higher level. It groups operations and data into modular units called
Quotes talked about in this paper
Terminology mentioned in this research paper
object-oriented programming, software development, data structures, Polymorphism, Assembly language, software engineers,
Technology talked about in this essay
Java, operating system,
Organizations included in this report
Health Conditions referenced in this report
Companies mentioned in this term paper
Keywords included in this term paper
object oriented, object oriented programming, code, object oriented software engineering, new class, software, abstract data types, implementation, software development, programmer, object oriented programming languages, a single, abstraction, design, dynamic loading, data structure, object oriented design, super, class hierarchy, higher level, object oriented code, class template, information hiding, space, object type, similar objects, class method, behavior, solutions, object oriented language, inheritance hierarchy, type equivalence, procedural programming, solution space, physical objects, structured programming, source code, brand new, A programming language, computer, paradigm, reusability, project, Code reuse, one to one mapping, Assembly language, functional decomposition, software development process,