The historical context of OOP
To understand the complex relationship that exists between computers, users, and programmers, it is necessary to look back in history and examine how this relationship has evolved over time. This relationship has been, and will be, far from static: it is subject to perpetual change for reasons that are dictated by the potential of computers and the preferences of their users.
The power of computers has grown dramatically over the 50 years that have elapsed since the creation of the ENIAC. For example, the ENIAC could calculate 5,000 additions per second, while a modern 150Mhz Pentium microprocessor can do 300 million additi ons per second, making it 60,000 times faster than the ENIAC. Advances of similar magnitudes have been achieved in memory development, reliability, portability. (Prof. Mitchell Marcus, Copyright 1996 The New York Times Company -- *ENIAC versus the Pentiu m, http://mbhs.bergtraum.k12.ny.us/cybereng/nyt/databox.htm) These advances have made it possible for software to become more powerful, while simultaneously forcing software to handle increasingly complex situations.
Early programming languages, particularly assembly languages, had to work with computers that had only a tiny amount of memory. Therefore, the primary requirement for such languages was to maximize the efficiency of the transformation from code to mac hine language and minimize memory use accordingly. As computers began to be used for scientific, educational, and business applications, a new set of languages was developed. These languages, such as FORTRAN and COBOL, made it easier for a programmer to write and debug code, while nearly preserving the efficiency of the assemblers. Because the compilers, not the programmers, were now responsible for translating programs into machine code, programmers were better able to concentrate on problem-solving r ather than arcane encryption.
The increasing power of computer hardware in the 1970's made it possible to shift the focus from memory efficiency to the ease and effectiveness of software creation. Better structured and more reliable languages like C and Pascal were developed to su ite these needs. They focused on abstract data types, strong typing and static program checking, generic modules, exception handling, concurrency, and interprocess communication and synchronization. However, advances in hardware and software brought alo ng a new set of problems as well. The development of sophisticated computer graphics required new methods for handling previously non-existent capabilities. Software was allowed to become increasingly complex due to the better hardware base, but this im plied that more and more people would have to work on increasingly longer team projects. As software projects grew, the code became increasingly extensive and difficult to integrate and debug. These issues were first seriously addressed at the NATO Scie nce Committee conference devoted to programming issues in 1968 (Ghezzi, p. 16). It was decided that software should be engineered according to certain rules ("the application of a systematic, disciplined, quantifiable approach to the development, operation and maintenanc e of software"). The result was an increasing focus on clear, structured, easy-to-understand code.
The needs to respond to the demands of sophisticated new technology, to solve the problem of large, unwieldy projects, and to write better software combined in the seventies and eighties to foster the creation of a new set of programming tools: object- oriented languages. The extensive libraries that could be easily integrated into OOP languages made it easier to solve often repetitive graphics problems by reverting to an existent set of functions. Modularization, which is inherent in the OOP paradigm , allowed programmers working in a team to write and test most of their code independently, thus making large team projects possible. The OOP technologies were well adapted for solving rising problems, such as global networking. Lastly, the object-orien ted paradigm was conducive to the production of cleaner, more reliable code by shielding each class from the other classes it had to interact with.
The other force which lead to the development of OOP came from the users of computers. As computers became more powerful, and their applications more diverse, they also grew cheaper. What was once available only to scientists in big universities or to government official could be accessed by the general public. With min i- then micro-comp uters, home computing became very popular. Hardware as well as software developers had a new and completely different market to cater to. Computers had to become smaller (laptops) and more functional (i.e. Windows allowed many applications to be run at th e same time). This is where Object Oriented Programming comes into the picture. With a rising demand for unconventional applications, such as computer networks, e-mail, etc. a new types of software became necessary. The democratization and standardizatio n of computer use, together with the perceived need for greater human control over the computer, contributed to the rise of object-oriented languages such as Smalltalk, C++, and Java.