Re: What is wrong with OO ?

[clovis@wartech.com]

In <32B81DA7.6D08@deep.net>, Tansel Ersavas <tansel@deep.net>, in a fit of
extreme hubris, wrote:

>Robert Dewar wrote:
>> 
>> Tansel says
>> 
>> "First of all, my opinion is, developing systems with procedure oriented
>> techniques is a dangerous, wasteful and unproductive process."
>> 
>> It is this kind of unsupporable hyperbole that gives OO a bad name!
>
>Unsupportable? Hyperbole? Are we mentioning about the software gap, or
>failed projects, or wasted money?
>Why don't you look at statistics about these?

The problem is bad coders.  Those of us who have been around for 20 years have
long ago noticed that 10% of the world's programmers could do 100% of the work
and not have it spontaneously collapse, by doing it right the first time.

This has nothing to do with paradigm. It has everything to do with a quality attitude
and the ability to conceptualize.

What OO will do is help wash some of the dross out of the coding pool.

But I've done enough Smalltalk in the past year to know that I can write just as
sloppily in Smalltalk, and make even bigger errors, harder to correct, as I code
my way along, without a previously completed design, as I can with anything.

If anything, Assembly Language is easier to fix, precisely because the procedures
are more amenable to "redesign" and "reuse" than a single hirearchy.

>Turning a blind eye on Today's problems will not get us anywhere. First
>of all, we should admit that we have a problem, then find a solution to
>it. We ALL contribute to lost billions by ignoring what's happening
>around us. 

What problems? The lack of good software is due to the lack of good education,
high levels of intelligence distributed all around in the people doing the work, and
so on.  People do programming.  OO CAN be easier, in something like Smalltalk,
because there is so much framework for grunt stuff like the GUI.

So I greatly differ with your take on things here.

>> Why is it that when anyone comes along with new techniques that represent
>> a useful incremental advance in our knowledge in this area (e.g.
>> functional programming, proof of correctness, your-favorite-fad-here)
>> they feel compelled to hype them like this with the approach
>
>OO is not an incremental advance. It has started and continued that way,
>because SIMULA was an extension to Algol, and some of the most dominant
>languages are extensions of procedure oriented languages. This does more
>harm than good to OO. Many professionals I have talked to told me that
>until they made a switch ( or some of them call it a "click") they
>weren't able to benefit from OO a lot. It is more difficult to have that
>"click" if we have to work in an environment and a language which is
>basically an OO extension to a procedural background. 
>It is true that every newcomer announces that it is a significant
>advancement over procedure orientation. This is because people are
>worried about the current paradigm, and they in search for a better one. 

Smalltalk and other OO paradigms are an unmitigated disaster at certain kinds
of problems.  Ask me about Modified Midpoint integration or, say, adaptive Runge-
Kutta under Smalltalk.  We give up as much as two orders of magnitude in
computational efficiency.  The more a tool does for you, the more it also does
to you.

What is being complained about here is that you treat OO as though a pure OO
language "gives" all this good stuff without a price.  And, in reality, the price is
quite high.

>> The trouble with such hype is that inevitably it does not deliver, and then
>> there is a danger of throwing out the baby with the bathwater and
>> discarding what is useful along with the hype.
>
>OO as is now, is a struggling, and not much appreciated figure around.
>It has its troubles, but they are slowly being ironed out. Yes, there
>may be a short term backlash against OO, it may even go back a couple of
>years. This is not important. It will come back, and will eventually
>dominate.  

I don't find anything "struggling" about using VisualWorks or IBM's VisualAge on
Windows, OS/2 or OSF/Motif platforms -- they are basically just extentions of
GUI paradigms built on top of Smalltalk/80 to begin with, so they are quite
natural and straightforward to use -- ONCE ONE HAS CRACKED INTO THE HIREARCHY.

The chief complaint I have about OO is that one has to learn a hirearchy, and one
which is in the general case sloppily and amateurishly documented, instead of the
better understood and generally much better documented procedural library.

This inferior documentation is, in my view, the reason for OO's lack of popular
success.  It is, much as you are displaying here, more of a religion for its 
adherents than it is regarded as what it should be -- a convenience tool.

There is nothing OO can do that pure object code can't do.

All we're doing is adding the hirearchy to raise the level of abstraction, so one
doesn't have to spend as much time fussing with daily details.

>> The fact of the matter is that there is NO giant shift of paradigm involved
>> here, despite what anyone says. Just look at the OO programs that people
>> produce. They are not radically different from conventional procedural
>> programs, and one would not expect them to be.
>
>Unfortunately, many OO programs that people produce are produced by
>people who are learning. They will be better and better, the gap will be
>larger and larger, and differences will be more and more obvious.

Duh! This is arrogant nonsense, sir. OO cannot and will not make a case for itself
until it can demonstrate to the average working programmer something in the way
of return for the struggle to learn the hirearchy.

>People have short memories. A very similar sort of discussion with
>similar tones was done when first high level languages were introduced.
>Proponents of machine code and assembly languages said, this new
>paradigm was nothing new, just a bigger, bulkier way of doing the same
>thing with speed penalties, it was not practical, people would never
>program with them in masses, etc, etc. Now we see everything has settled
>down, there are still people write code in assembly and nothing else,
>however they are the minority.

Yes, Assembler is the minority.  And as a result Microsoft Word wants 120 megs on
a disk, where WordStar lived comfortably in 64k, code and data both.  Word does
very little more.

Seems we were told the truth to begin with, eh?

Word barely runs in 8 megs of RAM.

You started out talking about waste.  Why 8 megs instead of 64k?

We have some differences of opinion here.

Regards,

Frank