Jump to content

  • Log In with Google      Sign In   
  • Create Account

We're offering banner ads on our site from just $5!

1. Details HERE. 2. GDNet+ Subscriptions HERE. 3. Ad upload HERE.


BASIC

  • You cannot reply to this topic
17 replies to this topic

#1 dave j   Members   -  Reputation: 594

Like
1Likes
Like

Posted 19 September 2013 - 07:18 AM

Many many years ago I was asked to alter a program written in BASIC by someone who had been learning to program as they went along. It was obvious that they only discovered subroutines part way through when I found the equivalent of the following in several places throughout the code:

10 REM early bit of code
20 GOSUB 40
30 GOTO 60
40 REM stuff they later decided they wanted to use in several places
50 RETURN
60 REM some more program
70 GOSUB 40
80 REM rest of program
90 END


Sponsor:

#2 Vortez   Crossbones+   -  Reputation: 2704

Like
0Likes
Like

Posted 19 September 2013 - 12:18 PM

Now i understand where the "dont use goto" come from lol. Using lines numbers to jump is such a dumb idea. I sometime use 1 when i need to jump to the same place from multiples location inside a function, but that about it, and try to avoid them at all cost.


Edited by Vortez, 19 September 2013 - 12:18 PM.


#3 Sik_the_hedgehog   Crossbones+   -  Reputation: 1813

Like
1Likes
Like

Posted 19 September 2013 - 03:40 PM

The procedural equivalent happens all the time too (where function calls become wrappers to other calls, etc.). It's probably a good way to save time.

 

Want something bad? On some code I worked not long ago somebody didn't figure out how to call subroutines yet, so he resorted to using an IRQ for the job instead... To give you an idea, that's like spawning a new thread just to call a function. Yuck.


Don't pay much attention to "the hedgehog" in my nick, it's just because "Sik" was already taken =/ By the way, Sik is pronounced like seek, not like sick.

#4 Ravyne   GDNet+   -  Reputation: 7802

Like
1Likes
Like

Posted 19 September 2013 - 04:23 PM

There are some neat tricks you can do in a similar way to save code-space, for example if you have reoutines to calculate sine and cosine, you can write the function for sine, and instead of writing a very similar function for cosine, you just add an instruction or two ahead of the sine function that shifts the cosine period to align with the sine period, and then continue through the sine function. There's not much reason to use this exact structure where code-space isn't a concern, but its common to see similar things where code-space is limited, such as in microcontrollers.



#5 Vortez   Crossbones+   -  Reputation: 2704

Like
0Likes
Like

Posted 19 September 2013 - 06:47 PM

Want something bad? On some code I worked not long ago somebody didn't figure out how to call subroutines yet, so he resorted to using an IRQ for the job instead... To give you an idea, that's like spawning a new thread just to call a function. Yuck.

 

lol


Edited by Vortez, 19 September 2013 - 06:47 PM.


#6 dave j   Members   -  Reputation: 594

Like
0Likes
Like

Posted 20 September 2013 - 03:33 AM


Want something bad? On some code I worked not long ago somebody didn't figure out how to call subroutines yet, so he resorted to using an IRQ for the job instead... To give you an idea, that's like spawning a new thread just to call a function. Yuck.


lol

I think that's more of an aaaargh! than a LOL.

#7 Sik_the_hedgehog   Crossbones+   -  Reputation: 1813

Like
0Likes
Like

Posted 21 September 2013 - 11:52 PM

There are some neat tricks you can do in a similar way to save code-space, for example if you have reoutines to calculate sine and cosine, you can write the function for sine, and instead of writing a very similar function for cosine, you just add an instruction or two ahead of the sine function that shifts the cosine period to align with the sine period, and then continue through the sine function. There's not much reason to use this exact structure where code-space isn't a concern, but its common to see similar things where code-space is limited, such as in microcontrollers.

Compilers will do it for you these days anyway.

 


I think that's more of an aaaargh! than a LOL.

That's an understatement (took me a while to figure out how to deal with that thing...).


Don't pay much attention to "the hedgehog" in my nick, it's just because "Sik" was already taken =/ By the way, Sik is pronounced like seek, not like sick.

#8 Cornstalks   Crossbones+   -  Reputation: 6991

Like
2Likes
Like

Posted 22 September 2013 - 01:00 AM

For those of you who are feeling particularly sadistic, try baysick. It's essentially a BASIC subset in Scala so you can write BASIC in your Scala code. And for those of you who aren't familiar with Scala, Scala is nothing like BASIC.


[ I was ninja'd 71 times before I stopped counting a long time ago ] [ f.k.a. MikeTacular ] [ My Blog ] [ SWFer: Gaplessly looped MP3s in your Flash games ]

#9 Sik_the_hedgehog   Crossbones+   -  Reputation: 1813

Like
0Likes
Like

Posted 22 September 2013 - 01:03 PM

That looks surprisingly usable actually...


Don't pay much attention to "the hedgehog" in my nick, it's just because "Sik" was already taken =/ By the way, Sik is pronounced like seek, not like sick.

#10 wodinoneeye   Members   -  Reputation: 857

Like
0Likes
Like

Posted 12 October 2013 - 03:09 AM

Many many years ago I was asked to alter a program written in BASIC by someone who had been learning to program as they went along. It was obvious that they only discovered subroutines part way through when I found the equivalent of the following in several places throughout the code:
 

10 REM early bit of code
20 GOSUB 40
30 GOTO 60
40 REM stuff they later decided they wanted to use in several places
50 RETURN
60 REM some more program
70 GOSUB 40
80 REM rest of program
90 END

 

 

The horrors of  GOTO  (jumps with index number labels)  would have started in early FORTRANs

 

Any instructor who says "NEVER" use GOTO  may never have done much serious programming  (where they are very useful for abnormal exiting of complex subroutines,  and the horrors of number goto labels are long gone)


Edited by wodinoneeye, 12 October 2013 - 03:12 AM.

--------------------------------------------Ratings are Opinion, not Fact

#11 Alpha_ProgDes   Crossbones+   -  Reputation: 4692

Like
1Likes
Like

Posted 12 October 2013 - 03:34 AM

That looks surprisingly usable actually...

 

If you're a hardcore BASIC user, yes. Otherwise, if you're sane, no. As in, Oh hell no.


Beginner in Game Development? Read here.
 
Super Mario Bros clone tutorial written in XNA 4.0 [MonoGame, ANX, and MonoXNA] by Scott Haley
 
If you have found any of the posts helpful, please show your appreciation by clicking the up arrow on those posts Posted Image
 
Spoiler

#12 wintertime   Members   -  Reputation: 1799

Like
0Likes
Like

Posted 12 October 2013 - 04:40 AM

Adding a quick goto must have been much easier for those people than listing a bit of code, guess some line number range thats free and will not be needed soon, editing all line numbers and hitting enter to copy them, listing it again, typing in the line numbers alone to delete the original, still remember all numbers and list the next bit cause the screen was too small, ...

And later they would have dicovered they moved the code to a place where they need the linenumbers now for new code and repeat it all again.sad.png

... or just add a quick goto at that point?tongue.png


Edited by wintertime, 12 October 2013 - 04:44 AM.


#13 Hodgman   Moderators   -  Reputation: 31096

Like
0Likes
Like

Posted 12 October 2013 - 05:45 AM


Any instructor who says "NEVER" use GOTO  may never have done much serious programming  (where they are very useful for abnormal exiting of complex subroutines,  and the horrors of number goto labels are long gone)
That depends on the language -- error cleanup based around goto is idiomatic in C, but in most modern languages the idiomatic thing to do is to use throw instead.

I'd probably still teach a class to never use goto, but then also teach that C error cleanup idiom as being the exception to this rule, and as a look inside how exceptional stack unwinding might be implemented in C++ wink.png



#14 Bregma   Crossbones+   -  Reputation: 5248

Like
0Likes
Like

Posted 12 October 2013 - 06:22 AM

10 REM early bit of code
20 GOSUB 40
30 GOTO 60
40 REM stuff they later decided they wanted to use in several places
50 RETURN
60 REM some more program
70 GOSUB 40
80 REM rest of program
90 END
That's just pretty much how BASIC required code to be structured. That's not Microsoft Basic or whatever the language evolved into over the generations. That's BASIC as it was originally designed and popularized. That's what those pages of listings looked like as you typed them in to your TRS-80 or VIC-20 or whatever from your favourite magazine.

It's no more of a coding horror than Chaucer's Tales or Shakespeare's plays are an English literature horror. Of course, some sophomores may agree with that statement, but entirely for the opposite reason.
Stephen M. Webb
Professional Free Software Developer

#15 wintertime   Members   -  Reputation: 1799

Like
1Likes
Like

Posted 12 October 2013 - 09:06 AM

I guess it was put here cause it was thought it should look like this:

10 REM early bit of code
20 GOSUB 1010
30 REM some more program
40 GOSUB 1010
50 REM rest of program
60 END
1010 REM stuff they later decided they wanted to use in several places
1020 RETURN



#16 dave j   Members   -  Reputation: 594

Like
0Likes
Like

Posted 12 October 2013 - 10:43 AM

I guess it was put here cause it was thought it should look like this:

10 REM early bit of code
20 GOSUB 1010
30 REM some more program
40 GOSUB 1010
50 REM rest of program
60 END
1010 REM stuff they later decided they wanted to use in several places
1020 RETURN
Very much that.

I was fortunate to learn programming using BBC Basic, which had procedures[1] and functions amongst many other things so finding that bit of MS BASIC[2] was a bit of a shock.

[1] I remember one program in a magazine having a delay procedure called PROCrastinate.
[2] MS BASIC might have evolved to have more modern features but didn't have them at that time.

#17 smr   Members   -  Reputation: 1676

Like
1Likes
Like

Posted 12 October 2013 - 11:02 AM

Any instructor who says "NEVER" use GOTO  may never have done much serious programming  (where they are very useful for abnormal exiting of complex subroutines,  and the horrors of number goto labels are long gone)


I've been programming for 20 years, professionally for 12, and I can say this is the first time in probably about six years that I've typed the four letter sequence "g o t o". When I did use goto, it was always preceded by "on error", because that's the exception handling idiom in VBScript - "On error goto label". I program at least 40 hours per week.

#18 wodinoneeye   Members   -  Reputation: 857

Like
0Likes
Like

Posted 12 October 2013 - 11:04 PM

 


Any instructor who says "NEVER" use GOTO  may never have done much serious programming  (where they are very useful for abnormal exiting of complex subroutines,  and the horrors of number goto labels are long gone)
That depends on the language -- error cleanup based around goto is idiomatic in C, but in most modern languages the idiomatic thing to do is to use throw instead.

I'd probably still teach a class to never use goto, but then also teach that C error cleanup idiom as being the exception to this rule, and as a look inside how exceptional stack unwinding might be implemented in C++ wink.png

 

I found Try and Catch to be about the same confuscation  in complex code  when a nice  well named goto label can make clear not only where the jump is going (I indent in a way labels stick out) but also (can) describe why.   I guess then its a matter of proper commenting for that anyway.    I recall good ole Pascal in a class where the instructor didnt want gotos and having bothersome condition checking at every nested layer of loops/blocks  to allow for the 'quick' exit.

 

I mention 'complex' code usually for this kind of issue because of the extra padding lines try/catch/finally  can add to an already  bulky/twisted  block of code (and rethrowing exceptions out thru  layers of calls...).

 

Systematic use of Gotos  as part of a state engine scheme is another place I have commonly uses goto labels  (where jumping upwards for retry situations  can happen alot)


Edited by wodinoneeye, 09 December 2013 - 01:37 PM.

--------------------------------------------Ratings are Opinion, not Fact





PARTNERS