From Wikipedia, the free encyclopedia

Unstructured programming is a programming paradigm where all code is contained in a single continuous block. This is contrary to structured programming, where programmatic tasks are split into smaller sections (known as functions or subroutines) that can be called whenever they are required. Unstructured programming languages have to rely on execution flow statements such as Goto, used in many languages to jump to a specified section of code.

Unstructured source code is notoriously difficult to read and debug, and so is discouraged in programming languages that support any kind of structure. However, structure is not needed in any programming language since program structures can always be implemented by a combination of conditional statements and Goto statements. Unstructured programming is still used in some scripting languages such as MS-DOS batch files, older programming languages such as BASIC or FORTRAN. Despite Goto statements (jumps) having a small performance benefit over procedure calls, current CPU architectures have made the difference negligible. In fact, the improper use of such statements can be harmful, either by obfuscating code and/or preventing good compiler optimization.

Assembly language is mostly an unstructured language, because the underlying machine code never has structure. The only structure it has, beside the basic "Jump to Subroutine" (mostly on stack-based machines), describes things required by compilation tools, such as where a function begins and ends.

Modern programming is primarily structured; however, the structured paradigm can prove too restrictive, and some logic is much more easily expressed as unstructured (references at structured programming).

Notable examples are:

• Return

Returning from a function exits a function without executing the remaining code (similarly, breaking out of a loop, or continuing with the next iteration); this is so valuable that it is widely accepted in structured languages

• Exceptions
• Continuations

Continuations are the general functional form of Goto.

Structurally, thinking of a structured program as a tree of function calls,

• return lets you exit this node at any point
• exceptions let you exit up the tree until caught
• continuations let you move from one point in the tree to a previously visited point,

not necessarily just an immediately calling function (you can "continue" where you left off)

• GOTO
• Structured programming (contrast)
• Spaghetti code
• Programming paradigms

 This computer programming-related article is a stub. You can help Wikipedia by expanding it.