
Object Oriented Programming has Failed Us - nreece
http://blog.dmbcllc.com/2008/05/13/object-oriented-programming-has-failed-us/
======
greendestiny
Object Orientation failed because it's too hard to understand? I blinked in
incredulity. Object Orientation hasn't failed, but we're coming to appreciate
its short comings as a sole design paradigm. For C programmers, C++ gave them
access to variable execution via polymorphism (without ugly function pointers)
and more flexible scoping via classes. In languages that provide first class
and anonymous functions polymorphism is a lot less useful and closures provide
better scoping flexibility than classes. Languages that have these features
make it obvious how restrictive C++ is in binding this functionality in with
the type system. In languages like ruby, python, javascript, lisp and
smalltalk object orientation serves in its proper place as a type definition
system and people use it appropriately. It's only C++ that has failed us.

~~~
timr
_"closures provide better scoping flexibility than classes. Languages that
have these features make it obvious how restrictive C++ is in binding this
functionality in with the type system."_

C++ can/does do anonymous functions (for example, see boost lambda), and can
even give you most of what you want from first-class functions and closures
(using functors). The parts that you don't get are due mostly to the fact that
C++ doesn't have built-in garbage collection. It's a speed limitation, not a
type-safety limitation.

Now for my rant: there seems to be a backlash against type safety in this
forum that I don't understand. Granted, if all you ever do is develop dinky
webapps with your best friends, permissive languages allow for rapid
development (mostly because they let you get away with murder). However, once
you have more than a few developers and a few tens of thousand lines of code,
the benefits of strict typing become rapidly apparent. The chaotic, free-for-
all mentality of languages like Ruby is great for rapid prototyping, but it
kinda sucks for developing in more formal scenarios.

It may be "harder" to develop with strongly typed languages, but that's
_usually_ an indication that you're having to think a bit before you act.
That's rarely a bad thing!

~~~
DanielBMarkham
"there seems to be a backlash against type safety in this forum"

You've said what I've been thinking for many months now.

We've also got a strong contingent of anti-MS ranters.

As to the merits of the article -- there are none. Oddly enough, I can't make
a case against his argument because he doesn't have one, save his ultimate
realization that it was the language itself. "It came to me in a dream" is a
very difficult thing to take issue with.

~~~
aggieben
_We've also got a strong contingent of anti-MS ranters._

I've been having to work in MFC recently for a client, and boy...

If you ever needed a reminder why some people dislike C++ so much, just work
with MFC. It's one of the worst bastardizations of C++ I've ever seen (of
course, to be fair, one has to admit that much of the really sucky stuff in
MFC was done before the C++ standards were very good, and long before the
compilers caught up).

Writing C++ using std:: and boost:: and other libraries written in "Modern
C++" is pure bliss compared to doing it the "Microsoft Way".

~~~
DanielBMarkham
I mean MS in terms of the entire corporation, ie, all that comes from MS is
bad.

Last time I wrote in MFC was about five years ago. As I recall, I got up to
speed by reading a couple books which went over basic application design stuff
in Win32.

Didn't seem too bad to me -- I even did some COM stuff and some hooks and
such. But like I said, that was a while ago. I wasn't a crazy fan or anything,
but the tools did the work I wanted to do.

~~~
aggieben
My latest woes were in trying to take a program written in a Modern/Standard
C++ style and build in some existing sources that were written for MFC.

Talk about a black hole of tool-chain hell...

~~~
DanielBMarkham
Ya -- mixing complex hierarchical OO libraries and programming metaphors in
one project? It does sound like a trip through the underworld.

~~~
aggieben
But see, that's the point - C++ is intended to be multi-paradigm, and MS made
it one-dimensional. Stdlib and Boost both take advantage of multiple paradigms
while the MFC is a framework prison whence there is no escape.

~~~
DanielBMarkham
But it's not OOP's fault, and to the degree that Microsoft had to release
something early (in order to support their Win32 framework) and keep
supporting it -- it's not their fault either.

You can go with a lightweight (?!?!) framework around your API, a la MFC, or
more of a true framework, like OWL. But in either case, comparing a what?
12-year old framework system with something more recent isn't exactly apples
and apples.

I'm not trying to make excuses but heck, the whole reason we grow new
frameworks is because old ones get too bloated and brittle.

Rock on with Boost, but don't compare apples and oranges. Maybe it's me, but
professionals are supposed to know the hard-to-use crap and should be able to
swim around in that stuff like a fish in water.

Hey -- just my two cents. No matter how you cut it, C++ is a killer language
when it comes to complexity -- and that's without the freaking frameworks!

------
davidmathers
Hacker News Is Failing Us.

This link is currently in the #2 position on the front page. I wonder if the
people who up voted it actually read it or just agreed with the thesis?

~~~
greyman
Or, we are failing ourselves, but otherwise you are completely right. There is
nothing in the article explaining why author thinks that "Object Oriented
Programming has Failed Us".

Anyway, this is a good way to trick Hacker News:

1\. Write curious title with some programming term in it. 2\. Write some
random thoughts in the article body mentioning the term. 3\. Submit to HN 4\.
Traffic!

~~~
bkovitz
Actually, the article says that OOP has failed us by not being a good fit to
the way most programmers' minds work.

~~~
jshen
I say that the cause of global warming is the decrease in number of pirates on
the planet.

------
aggieben

      I really hate to say this, as much as I like object
      oriented programming but, I really think we might be better 
      off if we went back to procedural programming for the bulk 
      of the applications that we write and left the object 
      oriented stuff to people who really understand it and for 
      problems that can not be solved any other way.
    
      Meanwhile, back at the lab, we need to come up with a 
      programming environment that most people understand 
      naturally.  We need to do usability studies on the 
      languages we develop just like we test applications we 
      develop for users.  Instead of trying to simplify what we 
      are already doing, which continues to provide solutions 
      that only programmers understand, we need to provide 
      solutions that are no longer programmer centric.
    

Isn't this what we used to call Visual Basic?

~~~
stcredzero
It seems to be natural to do GUI-centric programming as in Visual Basic.
People like attaching ideas to things that they can see. I think that the real
problem is that there is an Impedance Mismatch between current GUIs and the
domain. Once we have solved this, then the natural way to program won't
conflict so drastically with good Object Oriented practices.

I'm not sure if we can get there before we reach the level of GUIs in Minority
Report, but I think we won't need quite _all_ of that.

------
softwarejim
I can't get passed the spelling and grammer mistakes personally

~~~
yan
"I can't get passed the spelling and grammer mistakes personally"

*grammar

~~~
jraines
*past

~~~
Xichekolas
Now that is ironic.

------
andreyf
_Meanwhile, back at the lab, we need to come up with a programming environment
that most people understand naturally. We need to do usability studies on the
languages we develop just like we test applications we develop for users._

Isn't that how Vista was designed? Wouldn't it be a better idea to have a
really curious and imaginative person (an artist, if you will) work on the
language that will last 100 years?

On the other hand, I think this article borders on a good criticism of Arc:
could it be that PG's focus on writing a _language_ is misguided? Maybe it
would be a better idea to focus on something more abstract: in particular, on
inventing better fundamental representations for our programs (as Alan Kay
did, when he thought about OOP)? I'd imagine Paul's response would be that
macros -the "blurring of the line" between interpreter and interpreted- is the
mind-opening change in representation. Does the problem lie in helping people
cross this line?

~~~
SwellJoe
It's also how Mac OS X, Windows XP, Windows 95, and most of their precursors
were designed. There's just been an acceptance amongst OS designers that
testing with real humans is the only way to know if things are actually easy.

Programming languages are unique, however, in that the people building them
are often also the users (and the more this is true, the better the language
tends to be). C was designed to build UNIX, while ADA was designed for a
customer...and we know which one survived.

But, I also simply can't buy the "people understand naturally" logic. People
understand very little "naturally"...and even if you include pre-existing
knowledge (like English, or spatial skills) in this "natural" knowledge you
still end up with a pretty horrendous and limited programming language.
Explaining an algorithm in English almost always takes a lot more "code" than
writing it in a decent high level language.

~~~
andreyf
_testing with real humans is the only way to know if things are actually easy_

Yes, yes, of course, sorry for being unclear - I just meant that we shouldn't
rely on design-by-focus-groups or design-by-committee exclusively, that
imaginative solutions require creativity, and for that you need someone with
taste.

 _People understand very little "naturally"..._

Well, OOP utilizes our spacial skills, at least in the form of all those
pretty UML graphs? There is certainly a lot of thinking left to do about _how_
exactly we understand programming languages, both on macro and micro levels -
what metaphors we use to understand scope, objects, functional concepts, etc.
It's from this thinking that new language designs will arise.

~~~
stcredzero
CRC cards on 3x5" card-stock are better than UML. Otherwise, I agree. Until
GUIs for applications are as natural as passing 3x5 cards around, there's
going to be an impedance mismatch between the GUI and the domain.

------
bporterfield
I find it very hard to agree with thesis when there is absolutely no backing
information about how OO programming is "hard". What are the difficulties
people are having with OO? How can I take this article seriously when it's
nothing more than a statement followed by some fluff followed by a few half-
thought suggestions. Who are these 'people these people who 'really
understand' OO programming?

Am I one of them?

Are you?

How are we to know with no example of HOW OO is hard? What exactly is so hard
about it? Class Apple extends Fruit. apple = new Apple(). apple.eat(). Makes
sense to me. How are people using it wrong? Is the real issue that people
don't understand when to use it?

Here's a similar article:

Playing poker is hard. A lot of people really don't understand how to play
poker. People that play poker should stop, and start playing go fish. They
should leave poker to the professionals that understand poker. All poker books
should now become go fish books.

------
thinkcomp
I don't think this article is particularly well-written. However, I do agree
with the conclusion. For web-based programming, object oriented programming is
simply ridiculous in all but a small number of cases. That's why the Lampshade
framework I wrote is purely procedural, and why I'm able to write software on
top of it so quickly. Client-side GUI programming is a different story, in my
opinion.

In general, just because you're capable of understanding complex, abstract
concepts doesn't mean that it's always best to use them.

~~~
andreyf
_For web-based programming, object oriented programming is simply ridiculous
in all but a small number of cases._

Agreed. Functional programming seems to make a lot more sense. Fundamentally,
isn't a web server just a function f: url -> html? Sure, databases and
sessions complicate things, but even in these cases, functional structures
seem a lot more elegant (in a mathematical sense) than OOP ones.

~~~
swombat
For any programming, OOP brings some advantages. What you might be decrying is
over-the-top abuse of OOP patterns. Certainly, for most programming, abuse of
design patterns is unwarranted.

However, taking, as an example, Ruby, which is both a functional and OOP
language, the OOP features make the language a lot nicer.

Anyway, that article is completely daft. And I refuse to take any advice about
programming from someone who spells "linear" as "linier". Shame there's no
down-mod button.

------
edw519
"...and left the object oriented stuff to people who really understand it and
for problems that can not be solved any other way."

And an example of such a problem would be...?

The single biggest problem with "language war" threads like this is that
people actually believe this is the "only way". "Better way"? Maybe. "Only
way"? Hardly.

Anything you can do in your language (object oriented or not), I can do in
mine. Maybe not as slick, but it _can_ be done.

