Spaghetti code

Short description: Software source code with poor structure

Cooked spaghetti, characteristically tangled

Spaghetti code is computer source code that encodes control flow that is convoluted, and therefore, hard to understand. Control statements direct program execution in ways that instead of having a quality of structure, resembles cooked spaghetti, twisted and tangled.[1] The code tends to be hard to maintain.

Since control flow logic encoded via the goto statement tends to lead to convoluted control flow, use of goto is often associated with a classification as spaghetti code.[2] The practice of structured programming was envisioned to eliminate the need for and use of the goto statement as one way to avoid the production of spaghetti code. Ensuring the creation of high-quality software, instead of spaghetti code, often involves aspects such as using better tools, training developers and improving software development processes.[3]

Spaghetti code can also describe an anti-pattern in which object-oriented code is written in a procedural style, such as by creating classes whose methods are overly long and messy, or forsaking object-oriented concepts like polymorphism.[4] The presence of this form of spaghetti code can significantly reduce the comprehensibility of a system.[5]

## Contents

* 1 History
* 2 Examples
* 2.1 Simple
* 2.2 More representative
* 3 Related
* 3.1 Big ball of mud
* 3.2 Pasta-related
* 4 See also
* 5 References
* 6 External links

## History

It is unclear when the phrase spaghetti code was coined. Martin Hopkins made an early reference to spaghetti in this context in 1972, writing that the "principal motivation behind eliminating the goto statement is the hope that the resulting programs will not look like a bowl of spaghetti."[6] In the 1978 book A primer on disciplined programming using PL/I, PL/CS, and PL/CT, Richard Conway described programs that "have the same clean logical structure as a plate of spaghetti",[7] a phrase repeated in the 1979 book An Introduction to Programming he co-authored with David Gries.[8] In the 1988 paper A spiral model of software development and enhancement, the term is used to describe the older practice of the code and fix model, which lacked planning and eventually led to the development of the waterfall model.[9] In the 1979 book Structured programming for the COBOL programmer, author Paul Noll uses the phrases spaghetti code and rat's nest as synonyms to describe poorly structured source code.[10]

In the Ada – Europe '93 conference, Ada was described as forcing the programmer to "produce understandable, instead of spaghetti code", because of its restrictive exception propagation mechanism.[11]

In a 1980 publication by the United States National Bureau of Standards, the phrase spaghetti program was used to describe older programs having "fragmented and scattered files".[12]

In a 1981 computer languages spoof in The Michigan Technic titled "BASICally speaking...FORTRAN bytes!!", the author described FORTRAN stating that "it consists entirely of spaghetti code".[13]

Richard Hamming described in his lectures[14] the etymology of the term in the context of early programming in binary codes:

> If, in fixing up an error, you wanted to insert some omitted instructions then you took the immediately preceding instruction and replaced it by a transfer to some empty space. There you put in the instruction you just wrote over, added the instructions you wanted to insert, and then followed by a transfer back to the main program. Thus the program soon became a sequence of jumps of the control to strange places. When, as almost always happens, there were errors in the corrections you then used the same trick again, using some other available space. As a result the control path of the program through storage soon took on the appearance of a can of spaghetti. Why not simply insert them in the run of instructions? Because then you would have to go over the entire program and change all the addresses which referred to any of the moved instructions! Anything but that!

## Examples

### Simple

The following BASIC code, a program that prints 1 to 100, is a relatively simple example of code that can be more easily understood with structured control flow instead of using goto. The use of `GOTO` for looping and lack of indentation leads to less than clear logic flow.

1 i=0
2 i=i+1
3 PRINT i
4 IF i>=100 THEN GOTO 6
5 GOTO 2
6 END

The following code produces the same result, but uses a structured loop statement and indentation to improve readability.

1 FOR i=1 TO 100
2     PRINT i
3 NEXT i
4 END

### More representative

The following code implements a numeric sorting algorithm. The use of goto statements results in a spaghetti-like nature to the control flow.

INPUT "How many numbers should be sorted? "; T
DIM n(T)
FOR i = 1 TO T
PRINT "NUMBER:"; i
INPUT n(i)
NEXT i
'Calculations:
C = T
E180:
C = INT(C / 2)
IF C = 0 THEN GOTO C330
D = T - C
E = 1
I220:
f = E
F230:
g = f + C
IF n(f) > n(g) THEN SWAP n(f), n(g)
f = f - C
IF f > 0 THEN GOTO F230
E = E + 1
IF E > D THEN GOTO E180
GOTO I220
C330:
PRINT "The sorted list is"
FOR i = 1 TO T
PRINT n(i)
NEXT i

## Related

### Big ball of mud

A big ball of mud is a software system that lacks a perceivable architecture. Although undesirable from a software engineering point of view, such systems are common in practice due to business pressures, developer turnover and software entropy. The term was popularized by Brian Foote and Joseph Yoder although they credit Brian Marick for coining the term.[15]

> A Big Ball of Mud is a haphazardly structured, sprawling, sloppy, duct-tape-and-baling-wire, spaghetti-code jungle. These systems show unmistakable signs of unregulated growth, and repeated, expedient repair. Information is shared promiscuously among distant elements of the system, often to the point where nearly all the important information becomes global or duplicated.

> The overall structure of the system may never have been well defined.

> If it was, it may have eroded beyond recognition. Programmers with a shred of architectural sensibility shun these quagmires. Only those who are unconcerned about architecture, and, perhaps, are comfortable with the inertia of the day-to-day chore of patching the holes in these failing dikes, are content to work on such systems.

> --Brian Foote and Joseph Yoder

> , Big Ball of Mud. Fourth Conference on Patterns Languages of Programs (PLoP '97/EuroPLoP '97) Monticello, Illinois, September 1997

### Pasta-related

Inspired by the popularity of spaghetti code, other pasta-oriented terms that describe the structural nature of code include:

Lasagna code
Lasagna code has layers that are so intertwined that making a change in one layer necessitates changing other layers too.[16]

Ravioli code
Ravioli code comprises well-structured classes that are easy to understand in isolation but in combination result in less than clear system design.[17]

## See also

* Code smell - Computer programming characteristic
* The Elements of Programming Style - 1978 book by Brian W. Kernighan and P. J. Plauger
* International Obfuscated C Code Contest - Computer programming contest
* Software brittleness - Description of how difficult software is to modify
* Software maintenance - Modification of software after delivery
* SQALE
* Technical debt - Qualitative description of the cost to maintain a system attributable to its low quality

## References

1. ↑ Horstmann, Cay (2008). "Chapter 6 - Iteration" (in en). Java Concepts for AP Computer Science (5th ed. [i.e. 2nd ed.]. ed.). Hoboken, NJ: J. Wiley & Sons. pp. 235–236. ISBN 978-0-470-18160-7. http://horstmann.com/bigjava3.html. Retrieved 2 January 2017.
2. ↑ Cram, David; Hedley, Paul (2005). "Pronouns and procedural meaning: The relevance of spaghetti code and paranoid delusion". Oxford University Working Papers in Linguistics, Philology and Phonetics 10: 187–210. http://mostlyharmless.org.uk/wp-content/uploads/2010/12/cramhedley-web.pdf. Retrieved 5 March 2018.
3. ↑ Markus, Pizka (2004). "Straightening spaghetti-code with refactoring?". Software Engineering Research and Practice: 846–852. http://itestra.com/wp-content/uploads/2017/08/04_itestra_straightening_spaghetti_code_with_refactoring.pdf. Retrieved 5 March 2018.
4. ↑ Moha, N.; Gueheneuc, Y. G.; Duchien, L.; Meur, A. F. Le (January 2010). "DECOR: A Method for the Specification and Detection of Code and Design Smells". IEEE Transactions on Software Engineering 36 (1): 20–36. doi:10.1109/TSE.2009.50. ISSN 0098-5589. Bibcode: 2010ITSEn..36...20M.
5. ↑ Abbes, M.; Khomh, F.; Gueheneuc, Y. G.; Antoniol, G. (2011). "An Empirical Study of the Impact of Two Antipatterns, Blob and Spaghetti Code, on Program Comprehension". 2011 15th European Conference on Software Maintenance and Reengineering. pp. 181–190. doi:10.1109/CSMR.2011.24. ISBN 978-1-61284-259-2.
6. ↑ Hopkins, M. E. (1972): A Case fo the GOTO. In: ACM '72: Proceedings of the ACM annual conference - Volume 2, August 1972, pp 787–790, p 59 DOI:https://dl.acm.org/doi/10.1145/800194.805860
7. ↑ Conway, Richard (1978). A primer on disciplined programming using PL/I, PL/CS, and PL/CT. Winthrop Publishers. ISBN 978-0-87626-712-7.
8. ↑ Conway, Richard; Gries, David (1979). An Introduction to Programming (3rd ed.). Little, Brown. ISBN 978-0-316-15414-7.
9. ↑ Boehm, Barry W. (May 1988). "A spiral model of software development and enhancement". IEEE Computer 21 (2): 61–72. doi:10.1109/2.59. Bibcode: 1988Compr..21e..61B.
10. ↑ Noll, Paul (1977). Structured programming for the COBOL programmer: design, documentation, coding, testing. M. Murach & Associates.
11. ↑ Schwille, Jürgen (1993). "Use and abuse of exceptions — 12 guidelines for proper exception handling". Ada – Europe '93 (Proceedings). 688. Springer Berlin Heidelberg. pp. 142–152. doi:10.1007/3-540-56802-6_12. ISBN 978-3-540-56802-5.
12. ↑ United States National Bureau of Standards (1980). ASTM special technical publication. United States Government Printing Office.
13. ↑ MTSBS[clarification needed] (March–April 1981). "BASICally speaking...FORTRAN bytes!!". The Michigan Technic 99 (4).[[[Wikipedia:Please+clarify|clarification+needed]]]&rft.au=MTSBS[[Category:Wikipedia+articles+needing+clarification+from+April+2015]][[[Wikipedia:Please+clarify|clarification+needed]]]&rft.date=March–April+1981&rft.volume=99&rft.issue=4&rfr_id=info:sid/en.wikibooks.org:Spaghetti_code">
14. ↑ Hamming, Richard (1996). The Art of Doing Science and Engineering. Taylor & Francis. ISBN 9056995006.
15. ↑ Foote, Brian; Yoder, Joseph (26 June 1999). "Big Ball of Mud". http://www.laputan.org/mud/mud.html#BigBallOfMud. Retrieved 14 April 2019.
16. ↑ Tomov, Latchezar; Ivanova, Valentina (October 2014). "Teaching Good Practices In Software Engineering by Counterexamples". Computer Science and Education in Computer Science (1): 397–405. https://www.researchgate.net/publication/301298530. Retrieved 5 March 2018.
17. ↑ De Troyer, O. (13 May 1991). "The OO-binary relationship model : A truly object oriented conceptual model". in Andersen, Rudolf; Bubenko, Janis A.; Sølvberg, Arne (in en). Advanced Information Systems Engineering. 498. pp. 561–578. doi:10.1007/3-540-54059-8_104. ISBN 978-3-319-98176-5. https://pure.uvt.nl/ws/files/5292185/DTO5613576.pdf.

## External links

* Go To Statement Considered Harmful. The classic repudiation of spaghetti code by Edsger Dijkstra
* We don't know where to GOTO if we don't know where we've COME FROM by R. Lawrence Clark from DATAMATION, December, 1973
* Refactoring Java spaghetti code into Java bento code separating out a bowl full of code from one class into seven classes
* Objects and Frameworks – Taking a Step Back by Brian Rinaldi
* Programming Pasta - Spaghetti, Lasagna, Ravioli and Macaroni Code
* Pasta Theory of Programming

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Spaghetti code. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Spaghetti_code&oldid=4299158"