GOTO

GOTO
Rama · CC BY-SA 3.0 fr · source
Name	GOTO
Created	1950s
Designer	Various
Paradigm	Imperative
Influence	Assembly language, Fortran, ALGOL, BASIC, C
Affected	Structured programming, compiler design, program verification

GOTO

GOTO is a control transfer construct originating in early assembly and high-level programming languages that causes an abrupt jump to another point in a program. It appeared in early compilers and interpreters alongside John Backus-era languages and influenced the design of Fortran, ALGOL, BASIC, C, and numerous assembly languages used on architectures by IBM, Digital Equipment Corporation, and Intel. Over decades GOTO has been debated by computer scientists, software engineers, and language designers including Edsger W. Dijkstra, Donald Knuth, and members of the ACM and IEEE standards communities.

History

GOTO's origins trace to unconditional branch instructions in early electronic computers such as the ENIAC and architectures documented by John von Neumann-style designs implemented at Bell Labs and Harvard Mark I. High-level incarnations arose in FORTRAN I implementations created by teams at IBM in the 1950s and were mirrored in COBOL committees and the Algol 60 working group. Debates about its use intensified with publications by Edsger W. Dijkstra in the late 1960s and early 1970s and responses from figures such as Donald Knuth and practitioners from Bell Labs and MIT. The structured programming movement, championed within organizations like the ACM and documented in textbooks by authors from Stanford and Princeton, produced language designs and programming methodology shifts away from liberal GOTO use. Compiler technology research at institutions such as Carnegie Mellon University and University of California, Berkeley developed techniques for optimizing away certain GOTOs and translating control flow into structured constructs.

Syntax and Semantics

GOTO typically appears as a keyword followed by a label identifier; examples were standardized in early dialects such as FORTRAN IV and BASIC where syntax variants like GOTO 100 or GOTO label were common. Semantically, GOTO effects an unconditional control transfer altering the program counter and bypassing intervening lexical scope, a behavior central to low-level assembly language branches found in x86 and ARM manuals. Implementations differ in how GOTO interacts with block scope, stack unwinding, and exception mechanisms as considered by language committees for C++ and Java undertaken by bodies such as ISO/IEC JTC 1/SC 22. Formal semantics of transfer statements have been modeled in operational semantics research at MIT and Princeton and in formal verification projects like those at Microsoft Research and INRIA.

Usage in Programming Languages

In early languages like Fortran and BASIC GOTO was ubiquitous for flow control in numerical code written at NASA, Los Alamos National Laboratory, and academic labs. Assembly programmers at Intel and Motorola used branch instructions equivalent to GOTO extensively in system software for Unix kernels and operating systems such as those developed at Bell Labs and AT&T. Later languages including C retained goto with constrained use cases such as error handling and breaking out of nested loops in systems developed at Unix System Laboratories and projects at Berkeley Software Distribution. Some modern languages like Python, Java, C#, and Ruby omit GOTO or discourage it; exceptions exist in languages such as Perl and PHP which offer label and goto-like constructs influenced by scripting traditions from Netscape and early web development at MIT Media Lab.

Criticism and Structured Programming Movement

Criticism of GOTO was foregrounded by Edsger W. Dijkstra's 1968 memo and subsequent essays within the ACM community arguing that GOTOs hinder program comprehension and correctness. The structured programming movement advocated constructs such as conditional statements and loops—exemplified in languages like Pascal and Algol—and promoted top-down design taught at institutions like Stanford University and Princeton University. Opponents including Donald Knuth argued for pragmatic, performance-conscious use and warned against doctrinaire elimination, a debate reflected in discussions at conferences such as ICSE and publications in journals like Communications of the ACM. Research in program verification by teams at Carnegie Mellon University and Oxford University showed that structured control flow simplifies formal proofs, influencing ISO language standards and compiler verification efforts.

Variations and Related Constructs

Variants of unconditional transfer include computed GOTO in Fortran 66 and BASIC's line-number-driven jumps, switch-based dispatches in C and Java's tableswitch/lookupswitch bytecode instructions in the JVM used by Sun Microsystems, and branch-and-link patterns in ARM and MIPS assembly for subroutine calls. Related constructs include labeled continue and break statements in languages such as Java and ECMAScript standardized by ECMA International, tail-call jumps in Scheme described by Guy L. Steele, and exception-based control transfer mechanisms developed by projects at Sun Microsystems and Microsoft. Compiler back-end optimizations like tail-call elimination and control-flow graph restructuring, advanced in research at Bell Labs and IBM Research, reduce reliance on explicit GOTOs.

Legacy and Modern Alternatives

GOTO's legacy persists in low-level systems programming, compiler intermediate representations like LLVM and GCC's RTL, and in bytecode formats used by virtual machines from Oracle and Google. Modern alternatives emphasize structured constructs: loop, if-then-else, switch/case, exceptions, and coroutines employed in languages from Rust and Go to Haskell and Scala developed by teams at Mozilla and Google. Formal methods communities at INRIA, Microsoft Research, and CMU continue to study control transfer abstractions to improve program correctness and maintainability, while system projects at Linux Foundation and Apache Software Foundation demonstrate pragmatic patterns where label-based jumps remain useful for performance-critical code paths.

Category:Programming language concepts