Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

What were some of the economic (and other historical) factors that led to object oriented programming languages becoming influential? I know that Simula started things off, but was the adoption of OOP languages due to the ever increasing needs of business? Or, was the adoption due more to the new things that could be done with OOP languages?

Edit I'm really most interested in whether there was some factors going on external to the languages themselves that allowed for them to take hold.

share|improve this question

migrated from history.stackexchange.com Mar 1 '12 at 4:56

This question came from our site for historians and history buffs.

    
That makes sense, but I guess I was more interested in the external circumstances that were going on during the development. It could very well be that external factors had a limited effect. –  ihtkwot Mar 1 '12 at 1:52
    
I guarantee you that even for a question regarding external factors, programmers.stackexchange is a better venue. It has a ton of people who actively work in the industry and many who've been working since the industry took off. You'll be much more likely to find a person there who has an excellent answer to your question than here. –  Opt Mar 1 '12 at 2:26
2  
Smalltalk did not start it off. Simula created the basic concepts of object orientation. What Smalltalk did was take those ideas and twist them into a very different model and appropriate the name. But it's worth noting that no language that follows the Smalltalk model of OO has ever actually been very successful for building programs. (With the exception of Objective-C, which is a special case: Apple shoves it down everyone's throats on their side, but no one outside the Apple ecosystem uses it.) All the successful OO languages: C++, Delphi, Java, C#, etc, use the Simula model. –  Mason Wheeler Mar 1 '12 at 5:22
1  
Lego toy bricks might fit in as an external influence... –  Jamie F Mar 1 '12 at 6:23
1  
@Mason: not sure what divides the Simula and Smalltalk models. Where would you put Ruby? LUA? Python? Javascript? –  kevin cline Mar 1 '12 at 16:37
show 1 more comment

4 Answers

up vote 9 down vote accepted

Short answer

I think it was the churn of software projects prior to OO days. OO helped by adding the fundamentally critical concept - Model the real world .


The first object oriented programming language was Simula way back in 1967. However, at that time software development at large was still in the labs more and most paradigms were still closer to hardware case.

Over a full another decade development of software for enterprise applications other commercial applications grew and software development at large picked up over the entire 1970's. Languages that still survives today of those age (prior to 1980) were C, Cobol, Fortran and similar other. Most of these languages are procedural. Lisp also existed since that day - however, i am not sure if that was prominent general purpose language for commercial development. The famous term Waterfall model was also coined in the early 1970's era.

In most commercial environment most important element emerge in software development was project management. There was a dire need for tight and at least predictable budgets and managing requirements to freeze to ensure that project reaches the finish line respectably. During this period was also one of the Mythical Manmonths back in 1975.

I guess by end of 70's people were burnt out - as procedural languages didn't keep up to those promises. And a new paradigm Object oriented which did existed since that time made it big. Though people might disagree, i think the C++ which help familiarity and proven experience and of C, and the Promise of Object orientation (originally with the name C with Classes) back in 1983 was a corner stone to the success of Object oriented programming.

Some reference for more perspective - http://journal.thedacs.com/issue/43/88

So why OO?

I think those days (if you look at the project success point of view) - it made sense that what you can understand better will be manageable better. Object oriented methodology with a promise "..everything in life is an object" seemed more like commonsense even before it was proven to be meaningful. The practical success of this factor was the very notion to sufficiently model the real world and problem at hand before jumping the gun - which i think something fundamentally new thing that OO offered which no other paradigm offered till that date. And definitely given that this paradigm forced you to somewhat think before you code more than procedural languages it showed visible success on the software projects that employed and since then they caught on!

EDIT
I would also add that programming languages evolved simultaneously in parallel to such fundamental concepts (OO paradigm, Aspect, Virtual machines, ) Each new concept and fresh thinking emerged only when a fresh new programming languages mastered it - keep only familiarity but change fundamentals from core! At the same time - these new concept and new languages only emerged because of new business problems. 1980's - OO for large scale software, 1990 Java in Internet age, PHP/ASP and many other for web. Innovation in programming languages were also driven mostly by discontinuous market need.

In summary, early 80s' was the age where larger scale commercial software took off - while projects with procedural languages had their problems, OO showed the better light and made projects more successful.

share|improve this answer
    
What was the caracterics of the shift and where to go? End of 70s. What maked developers understand thats time to go? Tired of procedural, yes, but there must ben of dousins of alternatives? –  Independent Mar 1 '12 at 6:03
    
@Jonas - ok - amended the answer. –  Dipan Mehta Mar 1 '12 at 6:13
    
As far as historical success we are evaluating- we can definitely say that familiarity plays some role. C (was successor of B), C++ was a better C even though OO was supposedly a paradigm shift. Even Java was a ready jump from C++ (which was more like C++ without C++ problems .eg. memory and portability). Most of this languages crossed chasms by acquiring existing space more effectively even though they had something more fundamental in them. More so, because every language will acquire some programmers who already know some other programming languages. BUT this may not be always true! –  Dipan Mehta Mar 1 '12 at 7:27
1  
I would also add that programming languages evolved simultaneously in parallel to such fundamental concepts (OO paradigm, Aspect, Virtual machines, ) Each new concept and fresh thinking emerged only when a fresh new programming languages mastered it - keep only familiarity but change fundamentals from core! At the same time - these new concept and new languages only emerged because of new business problems. 1980's - OO for large scale software, 1990 Java in internet age, PHP/ASP and many other for web. Innovation in programming languages were also driven mostly by discontinuous market need. –  Dipan Mehta Mar 1 '12 at 7:40
1  
"Model the real world" sounds conclusive, but in most cases, it doesn't happen. The Customer class doesn't have methods like eatLunch, goToWork or sleep, though this is what customers do in the real world. The Product class has several methods, though most products have exactly no behaviour at all in the real world. Therefore, I'd argue that the OO model only corresponds (more-or-less) in terms of properties, but not at all in terms of behaviour, with the real world. But you don't need OO to have a data model that corresponds to real-world objects. Record types is all it takes. –  user281377 Mar 1 '12 at 9:01
show 3 more comments

I see OOP as a natural evolutionary step from procedural code:

  1. Procedural code: Tell the machine to do A, then tell it to do B.
  2. OOP: Package the procedural instructions into very reusable chunks, by defining interfaces/input/outputs. (Warning: simplification.)

I'm sure someone with a wider view will chime in, but it seems like this was a natural progression in simply allowing programmers to produce code faster: i.e. allow greater code reuse.

In this view, the biggest external factor was reduced cost of processor horsepower (versus developer labor cost to create typical programs): computing overhead in using OOP classes became less of a concern than the developer time savings. (This same tradeoff of CPU expense versus programmer expense has influenced many other aspects of programming.)

share|improve this answer
add comment

I think the largest reason was the success of graphical user interfaces like X and Windows. A GUI consists of several objects which have a behaviour on their own, something that OO is able to represent closely.

On the other hand, a text-base user interface (that doesn't try to resemble a GUI) often simply follows a command-response pattern, which can be easily implemented in a procedural language. Business rules and similar stuff has been implemented with procedural languages for decades, without too many problems, and still today many OO programs for business applications are rather procedural; with stupid objects that hold the data and stateless objects that contain the business rules; the first could be records in a procedural langauge, the later could be, well, procedures.

share|improve this answer
add comment

In the beginning there was imperative programming (if you could call it that). Simple instructions that told the mainframe what and how it should be calculating. Those programming languages used unconditional jumps and other "unstructured" instructions, most of them exotic by today's standards.

Then somebody came up with structures for programming. The for, while, do while and foreach we know today. It was a big innovation since now applications with relatively complex flow could be written and understood easily. Thus structured programming was born.

Then came some other folks who said that you needed to repeat a lot of code here and there and it was a nightmare to maintain so a way of reusing code should be invented. People came up with procedures and functions to delimit reusable bits of code. This also gave birth to the encapsulation and single responsibility principles.

Then some academics said that functionality should be closely coupled with the data it is working on. Then they added the concepts of inheritance for code reuse and polymorphism to match the logical way classification worked in real life. Thus the third generation programming languages and OOP was born.

share|improve this answer
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.