When I say "goto", my parrot says "Spaghetti Code"
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
RandyBuchholz wrote:
Have we developed an irrational fear of
Speak for yourself. :-) Just look what I'm working on right now. Every opcode that starts with B is a branch (= goto). :-)
; =========================================================================================
; BIOS Command selection
;
; Parameters:
; ---
;
; Returns:
; ---
; =========================================================================================BIOS_Command: LDI hi(TxtEnterCommand)
STXD
LDI lo(TxtEnterCommand)
STXD
SEP R4
dw WriteLineCMD_Repeat: LDI 00FFH ; get RS232 input, max. timeout
STXD
SEP R4
dw RS232InSoftwareIRX ; timeout? LDX BZ CMD\_Skip STXD ; echo input STXD SEP R4 dw RS232Out IRX LDX SDI 006EH ; test input = n BZ CMD\_Exit LDX SDI 0079H BNZ CMD\_Repeat LDI hi(TxtNewLine) ; announce BIOS CMD STXD LDI lo(TxtNewLine) STXD SEP R4 dw WriteLine LDI hi(TxtNewLine) STXD LDI lo(TxtNewLine) STXD SEP R4 dw WriteLine LDI hi(TxtCmdTitle) STXD LDI lo(TxtCmdTitle) STXD SEP R4 dw WriteLineCMD_Prompt: LDI hi(TxtCmdPrompt) ; output the prompt
STXD
LDI lo(TxtCmdPrompt)
STXD
SEP R4
dw WriteLineLDI 00H ; get RS232 input, no timeout STXD SEP R4 dw RS232InSoftware LDI TRUE PLO RF IRX ; echo input LDX STXD STXD SEP R4 dw RS232Out IRX LDX ; test input = x SDI 0078H BZ CMD\_Exit LDX ; test input = X SDI 0058H BZ CMD\_Exit LDX ; test input = h SDI 0068H BZ CMD\_Help LDX ; test input = H SDI 0048H BZ CMD\_HelpCMD_Invalid: LDI hi(TxtCmdInvalid) ; error message (invalid command)
STXD
LDI lo(TxtCmdInvalid)
STXD
SEP R4
dw WriteLine
BR CMD_PromptCMD_Help: LDI hi(TxtCmdHelp) ; help text
STXD
LDI lo(TxtCmdHelp)
STXD
SEP R4
dw WriteLineLDI hi(TxtCmdHelp1) STXD LDI lo(TxtCmdHelp1) STXD SEP R4 dw WriteLine BR -
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
Sacrilege! You will goto hell for such thoughts! Oh wait. Even hell has been refactored:
while (true) burnInHellForever();;)Latest Article - Building a Prototype Web-Based Diagramming Tool with SVG and Javascript Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802
-
RandyBuchholz wrote:
Have we developed an irrational fear of
Speak for yourself. :-) Just look what I'm working on right now. Every opcode that starts with B is a branch (= goto). :-)
; =========================================================================================
; BIOS Command selection
;
; Parameters:
; ---
;
; Returns:
; ---
; =========================================================================================BIOS_Command: LDI hi(TxtEnterCommand)
STXD
LDI lo(TxtEnterCommand)
STXD
SEP R4
dw WriteLineCMD_Repeat: LDI 00FFH ; get RS232 input, max. timeout
STXD
SEP R4
dw RS232InSoftwareIRX ; timeout? LDX BZ CMD\_Skip STXD ; echo input STXD SEP R4 dw RS232Out IRX LDX SDI 006EH ; test input = n BZ CMD\_Exit LDX SDI 0079H BNZ CMD\_Repeat LDI hi(TxtNewLine) ; announce BIOS CMD STXD LDI lo(TxtNewLine) STXD SEP R4 dw WriteLine LDI hi(TxtNewLine) STXD LDI lo(TxtNewLine) STXD SEP R4 dw WriteLine LDI hi(TxtCmdTitle) STXD LDI lo(TxtCmdTitle) STXD SEP R4 dw WriteLineCMD_Prompt: LDI hi(TxtCmdPrompt) ; output the prompt
STXD
LDI lo(TxtCmdPrompt)
STXD
SEP R4
dw WriteLineLDI 00H ; get RS232 input, no timeout STXD SEP R4 dw RS232InSoftware LDI TRUE PLO RF IRX ; echo input LDX STXD STXD SEP R4 dw RS232Out IRX LDX ; test input = x SDI 0078H BZ CMD\_Exit LDX ; test input = X SDI 0058H BZ CMD\_Exit LDX ; test input = h SDI 0068H BZ CMD\_Help LDX ; test input = H SDI 0048H BZ CMD\_HelpCMD_Invalid: LDI hi(TxtCmdInvalid) ; error message (invalid command)
STXD
LDI lo(TxtCmdInvalid)
STXD
SEP R4
dw WriteLine
BR CMD_PromptCMD_Help: LDI hi(TxtCmdHelp) ; help text
STXD
LDI lo(TxtCmdHelp)
STXD
SEP R4
dw WriteLineLDI hi(TxtCmdHelp1) STXD LDI lo(TxtCmdHelp1) STXD SEP R4 dw WriteLine BRI have no fears! :-D My education is EE, and I still see registers (68xx architecture) in my head no matter what language I'm programming in. I don't actually see the code that way, it's just kind of a background image. It's amazing how many developers don't know that the only branching a CPU has is a `goto`.
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
I've not used the
gotokeyword in any of my C/C++/C# code over the last 20 years or so. I routinely usebreak(goto's more civilized brother, as it were) to exitforloops early. I do this in cases where expressing the iteration as aforloop is more appropriate for the general case, and thebreakhandles the exceptions. I don't tend to usecontinuenearly as much in similar situations; I'm not sure why. I dislike when code uses exceptions as an exotic form of iteration/flow control. My least favorite mechanism would have to besetjmp()/longjmp(), which is a very old C runtime library mechanism that fortunately doesn't see a lot of use today.Software Zen:
delete this; -
Sacrilege! You will goto hell for such thoughts! Oh wait. Even hell has been refactored:
while (true) burnInHellForever();;)Latest Article - Building a Prototype Web-Based Diagramming Tool with SVG and Javascript Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802
Not:
Quote:
while (true) burnInHellForever();
`while (false) burnInHellForever();` "true" believers go to heaven! ;P
-
I have no fears! :-D My education is EE, and I still see registers (68xx architecture) in my head no matter what language I'm programming in. I don't actually see the code that way, it's just kind of a background image. It's amazing how many developers don't know that the only branching a CPU has is a `goto`.
Even one as unconventional as this one here. :-)
I have lived with several Zen masters - all of them were cats. His last invention was an evil Lasagna. It didn't kill anyone, and it actually tasted pretty good.
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
I think it depends on the context. In C it's not so bad and I can think of a few notable examples where it is used. One instance I found rather humorous and posted in a coding 'hall of fame' page we used to have here, is in the default procedure of Windows v3.0 and the label used was "IcantBelieveIactuallyUsedAgoto." The source code of it was published in an old book by Peter Norton on windows programming. On the other hand, I think using goto in C++ is a really bad idea. Since objects are automatically deleted when they fall out of scope, a goto could result in memory leaks if not used very carefully. As far as I am concerned this opinion is not based on fear nor is it irrational. YMMV.
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
Back in 1988 when I went to university to study computer science we were taught that we were never to use
gotoexcept in one particular circumstance with COBOL. We were strictly taught structured programming and in the first year had 2 hours of computer time each week. Most of our work was done on paper. Fast forward to now and I am quite happy to use areturnstatement in code which in essence is agoto. I think in principle it's good to learn the rules of structured programming to know when it is ok to break those rules.“That which can be asserted without evidence, can be dismissed without evidence.”
― Christopher Hitchens
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
For several years programmers have had OOAD and OOP pounded into their heads, and goto is an inherently structured code construct. If you use goto in an object oriented program, you _are_ creating spaghetti code, which is why that particular reflex exists.
"There are three kinds of lies: lies, damned lies and statistics." - Benjamin Disraeli
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
I don't have an existentialism issue with goto. It can have its uses, very limited, but can be useful. We have a few in some of our older legacy C code. None in the new C++ code.
I'd rather be phishing!
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
It's not an irrational fear: it's a sensible precaution.
gotois a "shortcut" for lazy lecturers and lazy students - it positively encourages poor quality code and bad habits. That doesn't mean it shouldn't be used, just that you have to understand why you aren't using it before you should be allowed to use it. It has its place (try doing assembly code, or time critical embedded C / C++ without it) but generally speaking it's a bad idea in "modern" languages which have rich flow control constructs and a set of good practices which should mean that it isn't that necessary. For example, I've been coding in C# for nine years now, and not once have I needed to use agoto, nor have I had to "fudge round" not using one. It annoys me when it's taught early because the idiot running the course can't be bothered to teach awhile,for, orforeachloop to beginners. Because once you start using a hammer, every problem looks like a nail...Bad command or file name. Bad, bad command! Sit! Stay! Staaaay... AntiTwitter: @DalekDave is now a follower!
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
RandyBuchholz wrote:
Have we developed an irrational fear of
gotoborn out of ancient coding dogma? Or isgotoinherently and absolutely evil? :)Are we asking annoying questions, just for the sake of asking? Jumping to a label was once an improvement ovr jumping to a specific linenumber. You are doing as if using a "GOTO 40" still has a place in modern C# coding. It doesn't. No, it's not a dogma; you don't have to believe me and can feel free to GOTO anywhere in your code - it will be your problem, not mine :)
Bastard Programmer from Hell :suss: If you can't read my code, try converting it here[^] "If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.
-
RandyBuchholz wrote:
Have we developed an irrational fear of
gotoborn out of ancient coding dogma? Or isgotoinherently and absolutely evil? :)Are we asking annoying questions, just for the sake of asking? Jumping to a label was once an improvement ovr jumping to a specific linenumber. You are doing as if using a "GOTO 40" still has a place in modern C# coding. It doesn't. No, it's not a dogma; you don't have to believe me and can feel free to GOTO anywhere in your code - it will be your problem, not mine :)
Bastard Programmer from Hell :suss: If you can't read my code, try converting it here[^] "If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.
Quote:
Are we asking annoying questions, just for the sake of asking?
No, not just for the sake of asking, just for the sake of annoying. :) Also to see how many mind readers would jump on me for using them - even though I didn't say I used them. :) And don't, except in rare, low-level performance cases. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
-
Back in 1988 when I went to university to study computer science we were taught that we were never to use
gotoexcept in one particular circumstance with COBOL. We were strictly taught structured programming and in the first year had 2 hours of computer time each week. Most of our work was done on paper. Fast forward to now and I am quite happy to use areturnstatement in code which in essence is agoto. I think in principle it's good to learn the rules of structured programming to know when it is ok to break those rules.“That which can be asserted without evidence, can be dismissed without evidence.”
― Christopher Hitchens
GuyThiebaut wrote:
use a
returnstatement in code which in essence is agoto.No, it's that other thing, calling and returning from subroutines. A totally different animal, down to the machine code of the processor.
I have lived with several Zen masters - all of them were cats. His last invention was an evil Lasagna. It didn't kill anyone, and it actually tasted pretty good.
-
Back in 1988 when I went to university to study computer science we were taught that we were never to use
gotoexcept in one particular circumstance with COBOL. We were strictly taught structured programming and in the first year had 2 hours of computer time each week. Most of our work was done on paper. Fast forward to now and I am quite happy to use areturnstatement in code which in essence is agoto. I think in principle it's good to learn the rules of structured programming to know when it is ok to break those rules.“That which can be asserted without evidence, can be dismissed without evidence.”
― Christopher Hitchens
GuyThiebaut wrote:
Back in 1988
GuyThiebaut wrote:
the first year had 2 hours of computer time each week. Most of our work was done on paper.
I remember those days well!...being a CS major from around '87 to '89 when my part-time afternoon job turned into full-time, which meant almost no lab time. I quit school for 10 years and finally went back and finished. During my 10 year hiatus, I had very little contact with computers so coming back to it after a decade I was more than a little pleased to find that I could finally do homework at home...even in the wee hours of the morning! :-D :-D Somewhere in a box, in a closet, are notebooks with handwritten C, Pascal, and Fortran homework assignments. I also have some greenbar printouts with notes/grade. Deliverables for an assignment were typically handwritten pseudo-code and/or flowchart and the printout which contained source code and results. That junk probably won't make the next move! :laugh: It amazes me now to think about how different it was to learn programming back then. Nowadays, an answer to a question is usually just a few clicks away, back then we relied on books, our own wits, and occasionally teachers/aides who sometimes knew little more than we did. :) Thanks for the memories! :)
"Go forth into the source" - Neal Morse
-
Quote:
Are we asking annoying questions, just for the sake of asking?
No, not just for the sake of asking, just for the sake of annoying. :) Also to see how many mind readers would jump on me for using them - even though I didn't say I used them. :) And don't, except in rare, low-level performance cases. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
RandyBuchholz wrote:
even though I didn't say I used them. :)
That's not relevant to me, you're implying they may not be bad.
RandyBuchholz wrote:
This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
No, it hasn't. We have simple rules for the monkeys to follow; anyone who can actually think doesn't need them. So we can't do without that faith, since some people continously ignore everything in the manual. While I agree that a single goto won't kill anyone, I also haven't seen any practical C# example where using one would be justified.
Bastard Programmer from Hell :suss: If you can't read my code, try converting it here[^] "If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
This old chestnut again :sigh: there are better constructs available with less risk of abuse. I've not used a goto in well over 20 years and am quite happy to leave it that way.
Never underestimate the power of human stupidity RAH
-
Mention "goto" to many programmers and they'll say, "Never use them, they lead to spaghetti code." It's a conditioned response. It seems to be a definition - "Dad, what's for dinner?" - "We're having `goto`." - "Again?". Ask them to explain why it is so bad, and you'll likely get a blank stare, or they just chant "spaghetti, spaghetti, …" Of course, a misused `goto` can lead to spaghetti code, but a (misused) [`any reserved word`] can lead to [`some bad thing`]. Have we developed an irrational fear of `goto` born out of ancient coding dogma? Or is `goto` inherently and absolutely evil? :) Update: As suggested by englebart, I'm adding why I asked this question. It came out of a recent discussion. I was reviewing some code someone showed me (they didn't write it) that had a `goto` in it. He said the code was Spaghetti Code. When I asked why, he said because it had a `goto`. I asked why that made it spaghetti, and all he could come up with was that he was taught that. I asked about a few other "programming truths", and had much the same response. This is good, that is bad, but I don't really know why. I started thinking about how for some things, aspects of programming have become more faith than science.
'the imperative goto == the object oriented if', both have their uses and allow misuse. The degree of misuse is telling ...
-
GuyThiebaut wrote:
Back in 1988
GuyThiebaut wrote:
the first year had 2 hours of computer time each week. Most of our work was done on paper.
I remember those days well!...being a CS major from around '87 to '89 when my part-time afternoon job turned into full-time, which meant almost no lab time. I quit school for 10 years and finally went back and finished. During my 10 year hiatus, I had very little contact with computers so coming back to it after a decade I was more than a little pleased to find that I could finally do homework at home...even in the wee hours of the morning! :-D :-D Somewhere in a box, in a closet, are notebooks with handwritten C, Pascal, and Fortran homework assignments. I also have some greenbar printouts with notes/grade. Deliverables for an assignment were typically handwritten pseudo-code and/or flowchart and the printout which contained source code and results. That junk probably won't make the next move! :laugh: It amazes me now to think about how different it was to learn programming back then. Nowadays, an answer to a question is usually just a few clicks away, back then we relied on books, our own wits, and occasionally teachers/aides who sometimes knew little more than we did. :) Thanks for the memories! :)
"Go forth into the source" - Neal Morse
Thanks for the post! I am ambivalent as to whether I would rather learn CS now or back in the 80's. Back in the 80's there was no WWW or everything that came with it(given the internet did exist with JANET being the network we had access to). In some ways I think people have it harder nowadays because there is so much more to learn. On the other hand a kid with a laptop and network connection can easily educate themselves, to the same level I was at when I graduated, before they even start their course in CS. I think we expect more of graduates nowadays than we did back in the 90's when it was a given that your first few years would be on the job training and you understood that when you graduated that you basically knew very little.
“That which can be asserted without evidence, can be dismissed without evidence.”
― Christopher Hitchens
