Re: EGL: Integration or Migration?

Joe,

Just some short answers, because i don't think it will help much...

Actually, it's not false. The problem has to do with being able to
respond to change in the business world. OO languages, especially those
with strong typing, work best for static problem sets.

So strong typing works best for static problem sets??? Don't know really what
you mean. Static means that variable types are checked in compile-time,
not runtime (like RPG actually). Seems to me rather ok for business apps.
There are some rants on the internet about this (here we go again). The
"rubyists" and all dynamic typing enthusiasts. Dynamic typing is handy
if you quickly want to build web apps for op-and-mom shops where you
don't have 100Klocs of code to maintain. These apps are also often
"throw-away" apps, not apps that last 10-20 yrs such as in most businesses.
I programmed in smalltalk for a couple of years and the main advantage
java gave me (as some drawbacks like no closures but thats beside the
point) is that it is statically typed. If u change the type of a variabel the
compiler instantly shows me with red x's where i need to change code where
that variable is used. In smalltalk you had a method "value" or "value:" that
was used extensively. Try to find the implementor of a specific "value:"
method in a reasonable big project. The IDE does not know of types (because
it's dynamic) and thus has not enough information to provide you with the
implementors of THAT specific call to "value:". There are so many classes
that would implement "value:".

Problem is, all those cool kids on the block using Ruby etc only know about
building "simple" web apps, not building "and maintaining!" complex
business apps for years. It's a matter of slam together e web app and leave.
And those are also the people who have strong voices on the internet, are
active bloggers etc, because they think they've seen the light. You don't here
all those Java developers simply because Java is not cool anymore (it's
mature) and most Java developers simply do their jobs instead.

But it strikes me that you, Joe, say something like that. You also talk about
class hierarchies. If you want flexible software than you dont achieve that by
crafting class hierarchies. You do that by making the right abstractions (and
subclassing is not abstracting). And Java (or any other OO language) has more
and better facilities to do just that. What's so difficult about that. Its how you use it.
Anyway.... strong typing... static problem sets.... i stop talking now about this. I am
not going to respond to this OO / static is not good for flexible business apps non-sense
because i don't have the time for that.

One more thought.... using OO is certainly not a panacea. It was sold that way in
the 90's of course, like any new technology simply because there are people who
buy this. It's simple a tool under your belt, but a very poweful at that. But a good
programmer can make a very flexible and maintainable app with a procedural
language as a mediocre programmer cant make such an app in either language.
And to restrict the damage a mediocre programmer can better use a straight
forward procedural language with less possibilties to make a mess.

The most popular BUSINESS languages are still COBOL and RPG. And SQL.
Not an object among them.

And this, of course, is due to the "fact" that OO is not for business apps?



Alas... as i said, i don't want to talk this, there is lots of this kind of discussion
on the internet, like the static vs dynamic discussion. Although there is no
discussion about the applicability of OO for business apps. There is a lot of
discussion between proponents of several languages and features. But there is
no discussion whatsoever between proponents of OO languages and procedural
language. Of course there is critique, because OO can be applied badly with
horrifying results. There is also no discussion between pro free-format and fixed
format. Only in the RPG world.... Why would that be.... hmmm. Am i sounding
sarcastic? Well i am..... it all does not help the RPG community to go forward.

You should educate us, Joe, not steer us towards the newest and greatest of IBM.

Date: Fri, 6 Jun 2008 07:27:48 -0500
From: joepluta@xxxxxxxxxxxxxxxxx
To: egl-i@xxxxxxxxxxxx
Subject: Re: [EGL-i] EGL: Integration or Migration?

john e wrote:

Again Joe, you are saying that a procedural language is much more capable
to respond to business change than a OO language. I really have to object
(nu pun intended) to this generalization which is completely false and misleading.

Actually, it's not false. The problem has to do with being able to
respond to change in the business world. OO languages, especially those
with strong typing, work best for static problem sets: that is,
situations where the rules don't change. That's because you can create
a class hierarchy that depicts the situation today and not worry about
it. The single worst thing you can do in OO is make the wrong
dependencies, and no matter how good you are, radically changing
business rules can invalidate your dependencies, thus necessitating a
restructuring of your class hierarchy, which is the single most
expensive operation in the programming world - certainly more expensive
than a simple database change, which is the worst thing that will happen
in a procedural world.

An OO language has more features than a procedural one to organize you're code
into self contained modules and to make abstractions. Now, with these features you
you also have more possibilities to make a compete mess with random
dependencies all over. And this happens a lot in practice.

I disagree. If you're talking about the perfect world, then a good RPG
programmer can do just as much abstraction using called programs and
procedures as an OO programmer. The only OO feature that can't be
easily mimicked is inheritance, and inheritance is exactly what leads to
the rigidness I spoke of above. That's why most modern OO experts lean
towards composition rather than inheritance.

Anyway, RPG on the "i" is, in practice, much more productive than Java
on the "i". But this is NOT due to the OO capabilities of Java. To say that
procedural languages are much more capable of responding to business
changes is simply misleading.

Not in my experience. OO is just another tool and it has strengths and
weaknesses. It's primary weakness is that it reacts poorly to radical
changes in requirements. That's what makes it less appealing for
developing dynamic business rules.

In fact, when OO concepts are applied with
care and thought, it's the other way around (ever wonder why most - or
all - popular languages all have OO features, even PHP?).

No, I don't wonder why. It's because most programmers aren't business
programnmers. Ever wonder why there aren't many ERP packages written in
Java? Ever hear about the San Francisco project?

The most popular BUSINESS languages are still COBOL and RPG. And SQL.
Not an object among them.

I'm not saying that a dedicated team of Java experts couldn't put
together a decent business application over time. I'm just a saying
that a few RPG programmers could do it a lot faster.

Joe
--
This is the EGL on and around the IBM i (EGL-i) mailing list
To post a message email: EGL-i@xxxxxxxxxxxx
To subscribe, unsubscribe, or change list options,
visit: http://lists.midrange.com/mailman/listinfo/egl-i
or email: EGL-i-request@xxxxxxxxxxxx
Before posting, please take a moment to review the archives
at http://archive.midrange.com/egl-i.

_________________________________________________________________
Jouw nieuws en entertainment, vind je op MSN.nl!
http://nl.msn.com/