Re: why rpg and not cobol

Hi, John:

Thanks for those links to those sources.

The one you characterized as "crazy" appears to be just a different "take" on the subject. ;-)

The generations I described are the generally accepted definitions, but, like arguing whether a Ford is better than a Chevy, different people will have widely varying opinions on which is better, or which is "correct" etc. =-O

Also, what about so-called CASE tools? Many called those tools "4GL" ... since they typically generated 3GL code as their output.

AFAIK, the whole "structured programming" revolution took place within the "Third Generation" -- incremental improvements.

SQL definitely qualifies as "non-procedural" or "declarative" and thus '4GL" but it is interesting to note that SQL is often embedded within a 3GL to create programs. :-\ And the SQL stored procedure language (IBM DB2 SQL/PL, or Oracle's PL/SQL) is certainly "procedural" in nature.

I certainly was not trying to say that "4GL is better than 3GL" ... just stating the common definitions. In fact, in practice, I have found that it was usually better to use a language that was what I call "3 1/2 GL" that is, has 4GL features, but also allows you to "drop down" into 3GL code, when and where needed. That way, you get the benefits of and can leverage the 4GL features, but you can still solve any problem where 3GL code is required ... with at least some "pure" 4GL languages, that can be very difficult to do.

The original RPG, RPG II, and RPG III, and RPG/400, were very "declarative" in that you just filled in some coding forms, stating what you wanted (O-Specs), and described the input (I-specs), and you were essentially "done". You could then add C-specs (calcs) if needed, to augment what the cycle would do for you automatically. Of course, as soon as you switch to "full procedural" mode, RPG became very much just another 3GL. And, your comments about the complexities of the cycle are well justified; it could get very complex, depending on what features you used. Caveat emptor.

All the best,

Mark S. Waterbury

> On 4/11/2013 4:55 PM, John Yeung wrote:

On Thu, Apr 11, 2013 at 2:55 PM, Mark S Waterbury
<mark.s.waterbury@xxxxxxxxxxxxx> wrote:

Hi, John:

Idon't know what "murky" definitions you are referring to.

Sometimes the definitions themselves are not murky, but there is
disagreement about what unmurky definition to apply to a given
generation. Sometimes the definitions themselves are just murky.

Some texts don't even start the generations with machine language!
Though admittedly that is unusual.

Some sources require so-called "structured" programming as a requisite
for 3GL. Again, what that means exactly can differ, but the original
FORTRAN, COBOL, and BASIC are insufficiently structured, and thus not
even 3GL according to this requirement. Later versions of course grew
more features (and seemed to lose the insistence on all-caps names),
putting them squarely in what most people would agree is 3GL.

You already call 5GL murky yourself, and I'll grant that there is wide
agreement that 1GL essentially means machine language and 2GL
essentially means assembly. So the question is, what makes a language
3GL or 4GL?

You cite "procedural" languages as 3GL and "declarative" languages as
4GL. OK, so where are the functional languages? Would they be 4GL
because they are "nonprocedural"?

There is pretty wide agreement that SQL is declarative and that it is
4GL. But some sources call "report generators" 4GL (presumably where
RPG fits in). A lot of them basically throw anything database-related
into 4GL. Some require 4GL to generate 3GL code. IBM's EGL is often
cited as a 4GL, but it is not declarative in the sense that SQL is.
It's more like something between Java/C# and a modern scripting
language.

I would argue that RPG's cycle doesn't make it declarative. There are
still very rigid, very specific steps, and *you know precisely what
they are and what order they happen in* because the cycle is 100%
procedural. It just so happens you don't have to write the code for
it. And if you don't have a clear knowledge about what happens and
when in the cycle, you are very prone to getting your program wrong.
In contrast, SQL really does let you forget about the implicit parts.
You need basically no knowledge about what the query engine is doing.
(Yes, there can be performance implications if you really do know
nothing about what the query engine is doing, and thus many query
engines will let you in on their plans so you can "work together"
toward a better solution.)

I think one of the things that confuses 3GL versus 4GL is what
dimension we're referring to when we say 4GL is a step "above" 3GL.
Are we talking "further" from the hardware? Are we talking fewer
lines of code? Are we talking less concrete and more abstract? Sure,
these things do tend to be correlated, but the further we get from
machine code, the weaker the correlation. A language can be far away
from the hardware, yet still be verbose (less "powerful" per line of
code). There are languages that require very little code (extremely
powerful per line of code), yet are incredibly difficult for most
*programmers* to work with, never mind being accessible to
nonprogrammers (ease and accessibility being some of the oft-cited
goals of 4GL or 5GL).

I guess I may just be sensitive to the danger of thinking that because
4GL has a higher number than 3GL, that 4GL is somehow "better" than
3GL. In some ways 4GL is better, but in some ways it's really, really
not, no matter what definitions are being used.

John

P.S. Here's a sampling of the various sources I've found:

http://searchcio-midmarket.techtarget.com/definition/programming-language-generations

http://www.cs.bsu.edu/homepages/dmz/cs697/langtbl.htm

Here, someone who is very familiar with development on IBM i considers RPG 3GL:
http://leedare-plex2e.blogspot.com/2008/04/great-3gl-v-4gl-debate-part-i.html
http://leedare-plex2e.blogspot.com/2008/05/great-3gl-v-4gl-debate-part-ii.html
http://leedare-plex2e.blogspot.com/2008/05/great-3gl-v-4gl-debate-part-iii.html

http://en.wikipedia.org/wiki/Programming_language_generations

http://www.techopedia.com/definition/16347/programming-language-generations
http://www.techopedia.com/definition/24304/first-generation-programming-language-1gl
http://www.techopedia.com/definition/24305/second-generation-programming-language-2gl
http://www.techopedia.com/definition/24307/third-generation-programming-language-3gl
http://www.techopedia.com/definition/24308/fourth-generation-programming-language-4gl
http://www.techopedia.com/definition/24309/fifth-generation-programming-language-5gl

http://www.doc.ic.ac.uk/~nd/surprise_96/journal/vol2/mjbn/article2.html

http://passcisa.blogspot.com/2008/09/five-generations-of-programming.html

http://en.wikibooks.org/wiki/A-level_Computing/AQA/Computer_Components,_The_Stored_Program_Concept_and_the_Internet/Fundamentals_of_Computer_Systems/Generations_of_programming_language

http://www.answers.com/topic/what-are-the-generations-of-programming-languages

http://www.sonoma.edu/users/f/farahman/bhcosc/lectures/lec14chap13f04.pdf

This is the crazy one that doesn't start with machine language:
http://users.humboldt.edu/smtuttle/s11cs335/335lect15-2/maclennan-generations.pdf