Non-structured programming

Short description: Programming paradigm preceding structured programming

Non-structured programming (a.k.a. unstructured programming) is the programming paradigm that describes the state-of-the-art of programming before the structured programming paradigm was envisioned and involves the use of the goto statement for control flow such as selection (i.e. `if/then/else`) and iteration (i.e. `while` and `for`).

In general, the use of goto, particularly for selection and iteration, is criticized for producing unreadable, spaghetti code in the 1968 open letter Go To Statement Considered Harmful by Dutch computer scientist Edsger W. Dijkstra,[1] who coined the term structured programming.[citation needed]

Any programming language that provides goto can be used to write unstructured code. Notable languages that rely primarily if not exclusively on goto for control flow include JOSS, FOCAL, TELCOMP, any assembly language, batch file, and early versions of BASIC, Fortran, COBOL, and MUMPS.

## Contents

* 1 References
* 2 Sources
* 3 Further reading
* 4 External links

## References

1. ↑ Dijkstra (1968).

## Sources

* Dijkstra, Edsger W. (March 1968). "Letters to the editor: Go to statement considered harmful". Communications of the ACM 11 (3): 147–148. doi:10.1145/362929.362947. https://www.cs.utexas.edu/users/EWD/ewd02xx/EWD215.PDF. "The unbridled use of the go to statement has as an immediate consequence that it becomes terribly hard to find a meaningful set of coordinates in which to describe the process progress. ... The go to statement as it stands is just too primitive, it is too much an invitation to make a mess of one's program.".

## Further reading

* Cobb, Gary W. (1978). "A measurement of structure for unstructured programming languages". ACM SIGSOFT Software Engineering Notes 3 (5): 140–147. doi:10.1145/953579.811114. ISSN 0163-5948.

## External links

* BPStruct \- A tool to structure concurrent systems (programs, process models)

* v
* t
* e

Programming paradigms

Imperative|

| Structured|

* Jackson structures
* Block-structured
* Modular
* Non-structured
* Procedural
* Programming in the large and in the small
* Design by contract
* Invariant-based
* Nested function

|

Object-oriented|

* Class-based, Prototype-based, Object-based
* Agent
* Immutable object
* Persistent
* Uniform function call syntax

Declarative|

| Functional|

* Recursive
* Anonymous function (Partial application)
* Higher-order
* Purely functional
* Total
* Strict
* GADTs
* Dependent types
* Functional logic
* Point-free style
* Expression-oriented
* Applicative, Concatenative
* Function-level, Value-level
* Monad

|

Dataflow|

* Flow-based
* Reactive (Functional reactive)
* Signals
* Streams
* Synchronous

Logic|

* Abductive logic
* Answer set
* Constraint (Constraint logic)
* Inductive logic
* Nondeterministic
* Ontology
* Probabilistic logic
* Query

Domain-
specific
language
(DSL)|

* Algebraic modeling
* Array
* Automata-based (Action)
* Command (Spacecraft)
* Differentiable
* End-user
* Grammar-oriented
* Interface description
* Language-oriented
* List comprehension
* Low-code
* Modeling
* Natural language
* Non-English-based
* Page description
* Pipes and filters
* Probabilistic
* Quantum
* Scientific
* Scripting
* Set-theoretic
* Simulation
* Stack-based
* System
* Tactile
* Templating
* Transformation (Graph rewriting, Production, Pattern)
* Visual

Concurrent,
parallel|

* Actor-based
* Automatic mutual exclusion
* Choreographic programming
* Concurrent logic (Concurrent constraint logic)
* Concurrent OO
* Macroprogramming
* Multitier programming
* Organic computing
* Parallel programming models
* Partitioned global address space
* Process-oriented
* Relativistic programming
* Service-oriented
* Structured concurrency

Metaprogramming|

* Attribute-oriented
* Automatic (Inductive)
* Dynamic
* Extensible
* Generic
* Homoiconicity
* Interactive
* Macro (Hygienic)
* Metalinguistic abstraction
* Multi-stage
* Program synthesis (Bayesian, by demonstration, by example, vibe coding)
* Reflective
* Self-modifying code
* Symbolic
* Template

Separation
of concerns|

* Aspects
* Components
* Data-driven
* Data-oriented
* Event-driven
* Features
* Literate
* Roles
* Subjects

Comparisons/Lists|

Comparison (multi-paradigm, object-oriented, functional), List (OO, by type)

Portals
Access related topics|

* Computer programming portal

|

* * *

Find out more on Wikipedia's
Sister projects|

* Textbooks
from Wikibooks

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Non-structured programming. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Non-structured_programming&oldid=3990839"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template