Using OO concepts in RPG

> From: David Gibbs
>
> Just a small point ... but shouldn't that be "Implementation hiding"?  We
> don't want to hide information when we are programming ... we
> want to hide
> the implementation of that information.

In combination with your other post, David, I'd like to continue this
discussion in a less heated way.  But as I said way back when the first
posts to this thread were made (and as subsequent posts showed), this topic
can quickly veer into a religious debate.  As Hans pointed out, certain
parts of OO understanding are almost mystical, and some older dinosuars like
me need a sort of epiphany to make the transition.  For example, today it is
absolutely clear to me why I should never instantiate an application object
directly in my class, I should always use a factory, but it's nearly
impossible to explain without a lot of the other concepts in place.

So, my thought would be to first have some agreement on what techniques we'd
like to try to use in RPG.  Is information (or implementation) hiding one of
them?  If so, what do we mean by it?  Let's avoid the issues of whether or
not it's an OO concept, or worry about whether a given language has it.  The
only reason another language should be brought into the discussion is to see
how a particular concept is enabled, and then go back to the issue in RPG.

Now, does this belong here or on another list?  I think it depends on the
amount of traffic.  But if we keep it close to the bone, so to speak, and
stay out of the religious quagmires (this will require restraint on the part
of the big debaters like me), then I think we can perhaps begin to outline
some features we'd like to see.  And who knows, maybe we can collaborate to
put some of these into service programs.

In this line, here are some of the things I'd like to see:

1. Instantiation
2. Indirect method calls
3. Garbage collection
4. Inheritance (with or without overrides)
5. Protected fields

Anybody else?  And once we get a list, we can start to see what's doable.
For example, instantiations should be a simple %ALLOC.  But garbage
collection, at least in its most basic form, could be as easy as adding
every allocated object to a list, and allow a CLEANUP call to deallocate
them all.  It's only a partial answer, but it's a start.

Joe