GOTO still considered harmful? [closed] – Dev

The best answers to the question “GOTO still considered harmful? [closed]” in the category Dev.

QUESTION:

Everyone is aware of Dijkstra’s Letters to the editor: go to statement considered harmful (also here .html transcript and here .pdf) and there has been a formidable push since that time to eschew the goto statement whenever possible. While it’s possible to use goto to produce unmaintainable, sprawling code, it nevertheless remains in modern programming languages. Even the advanced continuation control structure in Scheme can be described as a sophisticated goto.

What circumstances warrant the use of goto? When is it best to avoid?

As a follow-up question: C provides a pair of functions, setjmp() and longjmp(), that provide the ability to goto not just within the current stack frame but within any of the calling frames. Should these be considered as dangerous as goto? More dangerous?


Dijkstra himself regretted that title, for which he was not responsible. At the end of EWD1308 (also here .pdf) he wrote:

Finally a short story for the record.
In 1968, the Communications of the ACM
published a text of mine under the
title “The goto statement considered
harmful
“, which in later years would
be most frequently referenced,
regrettably, however, often by authors
who had seen no more of it than its
title, which became a cornerstone of
my fame by becoming a template: we
would see all sorts of articles under
the title “X considered harmful” for
almost any X, including one titled
“Dijkstra considered harmful”. But
what had happened? I had submitted a
paper under the title “A case against
the goto statement
“, which, in order
to speed up its publication, the
editor had changed into a “letter to
the Editor”, and in the process he had
given it a new title of his own
invention! The editor was Niklaus
Wirth.

A well thought out classic paper about this topic, to be matched to that of Dijkstra, is Structured Programming with go to Statements, by Donald E. Knuth. Reading both helps to reestablish context and a non-dogmatic understanding of the subject. In this paper, Dijkstra’s opinion on this case is reported and is even more strong:

Donald E. Knuth: I believe that by presenting such a
view I am not in fact disagreeing
sharply with Dijkstra’s ideas, since
he recently wrote the following:
“Please don’t fall into the trap of
believing that I am terribly
dogmatical about [the go to
statement]. I have the uncomfortable
feeling that others are making a
religion out of it, as if the
conceptual problems of programming
could be solved by a single trick, by
a simple form of coding discipline!

ANSWER:

The following statements are generalizations; while it is always possible to plead exception, it usually (in my experience and humble opinion) isn’t worth the risks.

  1. Unconstrained use of memory addresses (either GOTO or raw pointers) provides too many opportunities to make easily avoidable mistakes.
  2. The more ways there are to arrive at a particular “location” in the code, the less confident one can be about what the state of the system is at that point. (See below.)
  3. Structured programming IMHO is less about “avoiding GOTOs” and more about making the structure of the code match the structure of the data. For example, a repeating data structure (e.g. array, sequential file, etc.) is naturally processed by a repeated unit of code. Having built-in structures (e.g. while, for, until, for-each, etc.) allows the programmer to avoid the tedium of repeating the same cliched code patterns.
  4. Even if GOTO is low-level implementation detail (not always the case!) it’s below the level that the programmer should be thinking. How many programmers balance their personal checkbooks in raw binary? How many programmers worry about which sector on the disk contains a particular record, instead of just providing a key to a database engine (and how many ways could things go wrong if we really wrote all of our programs in terms of physical disk sectors)?

Footnotes to the above:

Regarding point 2, consider the following code:

a = b + 1
/* do something with a */

At the “do something” point in the code, we can state with high confidence that a is greater than b. (Yes, I’m ignoring the possibility of untrapped integer overflow. Let’s not bog down a simple example.)

On the other hand, if the code had read this way:

...
goto 10
...
a = b + 1
10: /* do something with a */
...
goto 10
...

The multiplicity of ways to get to label 10 means that we have to work much harder to be confident about the relationships between a and b at that point. (In fact, in the general case it’s undecideable!)

Regarding point 4, the whole notion of “going someplace” in the code is just a metaphor. Nothing is really “going” anywhere inside the CPU except electrons and photons (for the waste heat). Sometimes we give up a metaphor for another, more useful, one. I recall encountering (a few decades ago!) a language where

if (some condition) {
  action-1
} else {
  action-2
}

was implemented on a virtual machine by compiling action-1 and action-2 as out-of-line parameterless routines, then using a single two-argument VM opcode which used the boolean value of the condition to invoke one or the other. The concept was simply “choose what to invoke now” rather than “go here or go there”. Again, just a change of metaphor.

ANSWER:

XKCD's GOTO Comic

A coworker of mine said the only reason to use a GOTO is if you programmed yourself so far into a corner that it is the only way out. In other words, proper design ahead of time and you won’t need to use a GOTO later.

I thought this comic illustrates that beautifully “I could restructure the program’s flow, or use one little ‘GOTO’ instead.” A GOTO is a weak way out when you have weak design. Velociraptors prey on the weak.

ANSWER:

I can only recall using a goto once. I had a series of five nested counted loops and I needed to be able to break out of the entire structure from the inside early based on certain conditions:

for{
  for{
    for{
      for{
        for{
          if(stuff){
            GOTO ENDOFLOOPS;
          }
        }
      }
    }
  }
}

ENDOFLOOPS:

I could just have easily declared a boolean break variable and used it as part of the conditional for each loop, but in this instance I decided a GOTO was just as practical and just as readable.

No velociraptors attacked me.

ANSWER:

Sometimes it is valid to use GOTO as an alternative to exception handling within a single function:

if (f() == false) goto err_cleanup;
if (g() == false) goto err_cleanup;
if (h() == false) goto err_cleanup;

return;

err_cleanup:
...

COM code seems to fall into this pattern fairly often.