RE: Why was GOTO removed from /free?

John,

When using a GOTO, understanding why a GOTO was used in a given line of code is pretty easy but when you see the tag, you have to look into what is using that tag so it does take more time to understand the code. I was also taught that you can't do structured programming correctly using GOTO's and in most of the programming classes I took (even the C class), using a GOTO in code I did resulted in an automatic F so I got out of the habit quickly.

LEAVESR does the same thing as a GOTO pointing to a tag on the ENDSR statement of a subroutine. If you need to do additional processing when an error occurs, you can always call a procedure or subroutine to do what you need to do and then follow it up with a LEAVESR. Something like this:

If ErrorHappened;
callp ErrorRoutine;
leavesr;
EndIf;

Matt

-----Original Message-----
From: rpg400-l-bounces@xxxxxxxxxxxx [mailto:rpg400-l-bounces@xxxxxxxxxxxx] On Behalf Of john e
Sent: Monday, April 27, 2009 7:21 AM
To: RPG programming on the AS400 / iSeries
Subject: RE: Why was GOTO removed from /free?



Ok, i know i started a discussion about this some time ago, let's not start a lengthy discussion again.

I know the discussion(s) about goto, and especially that it's bad practice.

But let me be clear about my stance about this. Reading your response i conclude that you suppose that i'm a proponent of goto because it's more efficient, etc.

1) Using goto is bad practice, do not use it, ever. Except, where it really helps. Nowadays this is when using a classic language like C, for handling error situations.

2) I was talking with respect to our specific situation, C-like RPG without exception handling, etc. Where we also have lots of "old" RPG code which do use a lot goto's (thats bad but it's reality).

Further, i don't understand your arguments. If i use goto "correctly", you will notice immediatly because the error handling code is not (not!) cluttered. I don't know why you have to read the whole program to now whether it's used correctly. E.g. subr. "ReadClient" uses goto. Why do you have to read the whole program to "know"? Subr. "ReadClient" is simply less cluttered and readable, instead of the "main" code being burried in nested if's and what not. And if everything is ok then this is the only place where goto is used.

The opcodes you mentioned do not cut it. I can't use leavesr, or "leave" to jump to "end-subr". It would be nice to have a "leave" with a tag, but we don't have it. There is also no exception handling, i.e. i can't throw/trigger my own exceptions. Not practically, anyway.

A simple effective solution would be to specifify a "leave" together with a tag, together with do .. enddo. The enddo is tagged and within this block i can do a "leave" and specify the tag. Can't do this now. I can simulate a do..enddo with dou 1=1, but opcode "leave" only leaves the most inner block.

But to be precise, i am talking about our specific situation, not about "goto's" in general. With programming, there are no hard rules. Being too dogmatic with theories and best practices can be counter productive. Apply the tool that is best for the specific situation. And sometimes, like when using RPG for handling error cases, goto is your friend, because there is no good alternative.

The best solution i can come up with is to use procedures instead of subroutines (which is a good idea anyway) and have an "exit" subroutine which can be called from within the procedure to do clean-up and exit the proc. It's clumsy but it avoids cluttered code.

Still, IMO "goto" should not be removed from RPG without at least a "structured" approach to escaping, i.e. opcode "leave" with a tag.

But like you already said, let us agree that we disagree and have it done :)

Date: Mon, 27 Apr 2009 03:36:03 -0700
From: rpg400-l@xxxxxxxxxxxxxxxx
To: rpg400-l@xxxxxxxxxxxx
Subject: Re: Why was GOTO removed from /free?

John,

I read the blog you're pointing to prior to replying. It did nothing to
change my opinion of GOTO. Please understand that the debate about GOTO
has been raging for at least 40 years, and we're really unlikely to
solve the question here.

Here's a link that discusses both sides of the question:
http://www.stevemcconnell.com/ccgoto.htm

But, I can only give my opinion. And my opinion is that RPG is better
off without GOTO in /free format.

It's important to understand that the vast majority of a programmer's
time is NOT spent writing code. It's spend reading and understanding
someone else's code so they know which part of the code needs to be
modified, which parts can be ignored, which parts aren't modified, but
still need to be re-tested, etc.

Even if you use GOTOs in the best possible way, it will take me longer
to read and understand your program flow because any point in the
program can jump to any other point in the program. You say that's a
non-issue because you'll use the goto "correctly" -- but if I'm reading
your program, how will I *know* that without taking the time to read
everything? However, if there are no GOTOs allowed in the language, I
don't have to worry about it.

IBM has provided op-codes like LEAVE, ITER, LEAVESR, RETURN,
MONITOR/ENDMON to make it easy to do the "good" style of GOTO without
using the actual GOTO statement. With those statements you can do the
"good" part of GOTO without resorting to GOTO opcode that causes so many
problems.

I dunno... I think we'll just have to agree to disagree.


john e wrote:

I think the problem is with the people, not the tools.
Developers writing bad code using goto still write bad code without the goto.

goto... IMHO, it's never actually BETTER with the goto. Not having it
forces people to structure their code around the way the program is
SUPPOSED to flow, and leads to better code in the long run.

In "normal" circumstances, yes, but in the case of error handling using goto can really make the code much more clean.

See the articles below for other opinions about this.
There really seems to be a consensus that using "goto" in a classic language like C or RPG (no exception handling) in situations where in case of an error the "supposed" flow of the code is to escape to "clean-up" code is much cleaner than using multiple nested ifs etc.

I know it's still available in "fixed" format, but in practice this actually means it's gone. You really don't want to code
/end-free
goto out;
/free

And i really don't know what practical problem this solves. You don't get clean code just be removing the "goto". Besides not many new RPG code is being written. The bulk of RPG is maintanance code which probably uses "goto". Now this code can't be easily converted to /free without the code being littered with /end-free .. /free. The removal of "goto" brings more problems than it solves, IMO.

The problem of abuse of goto is not solved with the removal, because most "abusers" are probably programmers which 90% of their time do maintenance now. And it's now more difficult to persuade them to convert to /free because of the ugly code littered with /free .. /end-free.

RPG is NOT "modern" such that goto is not necessary.

Date: Mon, 27 Apr 2009 02:19:11 -0700
From: rpg400-l@xxxxxxxxxxxxxxxx
To: rpg400-l@xxxxxxxxxxxx
Subject: Re: Why was GOTO removed from /free?

My personal opinion is that GOTO is a bad thing to have in a modern
language. I agree with the plethora of papers and articles that have
said this.

I do see your point to a degree. It's possible to use GOTO in a way
that isn't too bad... the problem is that it always starts out that
innocently, but then gets overused and leads to a mess. Usually, at
best, the code with the goto is "just as clean as" code without the
goto... IMHO, it's never actually BETTER with the goto. Not having it
forces people to structure their code around the way the program is
SUPPOSED to flow, and leads to better code in the long run.

Just my opinion.

Regarding it being "removed" from /free -- it wasn't removed, because it
was never in /free. The fixed format GOTO is still there, and can still
be used as always.

I have been writing GOTO-free RPG code now for 15 years (I started in
RPG/400) and at first it was really hard to get the hang of, and I felt
as you do that it was cumbersome and that I was avoiding it for no good
reason. But after doing it for awhile I found the gotoless code nicer.
Now, after so long, I would never even consider going back.

Also, RPG *does* support exceptions, although I wish IBM would make them
simpler to use -- but I do use those as well.


john e wrote:

Without giving something back...?

For clean error handling "goto" is often the best choice in a classic language (yes RPG is still classic, like C).

What problem has been solved now by just removing goto from RPG as we don't have exception handling in RPG as we have in C++ or Java?


http://eli.thegreenplace.net/2009/04/27/using-goto-for-error-handling-in-c/