On 11/20/24 21:05, Rich wrote:
> John Ames <commodorejohn@gmail.com> wrote:
>> On Wed, 20 Nov 2024 03:37:58 -0500
>> "186282@ud0s4.net" <186283@ud0s4.net> wrote:
>>
>>> Hmmmmmmmm ... how many now have EVER programmed in BASIC ? Should do
>>> a survey .....
>>
>> Lord, who hasn't!? Well, probably depends on how you choose to qualify
>> it - we still use VB6 in-house at $EMPLOYER, and FreeBASIC is my go-to
>> for hacking together quick utility applications in daily life, but I
>> haven't touched old-school line-number spaghetti-Gotoese BASIC since
>> childhood, and certainly never built any application of real complexity
>> with it. Bet more than a few people here have, though, especially if we
>> cross-posted over to a.f.computers...
>
> Given the typical age of most posters here, I'd say nearly every one of
> us has written /something/ in one or more of the 75 different variants
> of "BASIC" that have existed over time.
>

For me: BBC Basic, VAX Basic, Visual Basic (&VBA).

GOTO was deprecated before BBC Basic circa 1981. I never really saw it,
apart from reasonable GOTO error usages. Wasn't it more a sign of lack
of training than a linguistic feature?

On Thu, 21 Nov 2024 02:20:58 -0500, 186282@ud0s4.net wrote:

> On 11/20/24 10:46 AM, Rich wrote:
>>
>> If JS or Perl are your yardstick for "never liked" you must never have
>> attempted to write an AutoHotKey script to automate something on a
>> windows machine.
>
> Tried a hotkey daemon once, DOS-era, but eventually bought one writ
> by better programmers. Automated Winders ... again a real pain in the
> ass.

GUIs were never designed to be automated. Which is why trying to do so is
fiddly, fragile and just plain unreliable.

> DOS was better at that.

Command line, of course -- naturally better for automation purposes.
Though the DOS one was a pitiful toy reimplementation of what was, and
still is, available on *nix systems.

On 21/11/2024 07:20, 186282@ud0s4.net wrote:
> I take it you're also not a fan of Perl  🙂

Perfectly Execrable Rubbish Language

--
"And if the blind lead the blind, both shall fall into the ditch".

Gospel of St. Mathew 15:14

On 11/21/24 3:09 AM, Pancho wrote:
> On 11/20/24 21:05, Rich wrote:
>> John Ames <commodorejohn@gmail.com> wrote:
>>> On Wed, 20 Nov 2024 03:37:58 -0500
>>> "186282@ud0s4.net" <186283@ud0s4.net> wrote:
>>>
>>>> Hmmmmmmmm ... how many now have EVER programmed in BASIC ? Should do
>>>> a survey .....
>>>
>>> Lord, who hasn't!? Well, probably depends on how you choose to qualify
>>> it - we still use VB6 in-house at $EMPLOYER, and FreeBASIC is my go-to
>>> for hacking together quick utility applications in daily life, but I
>>> haven't touched old-school line-number spaghetti-Gotoese BASIC since
>>> childhood, and certainly never built any application of real complexity
>>> with it. Bet more than a few people here have, though, especially if we
>>> cross-posted over to a.f.computers...
>>
>> Given the typical age of most posters here, I'd say nearly every one of
>> us has written /something/ in one or more of the 75 different variants
>> of "BASIC" that have existed over time.
>>
>
> For me: BBC Basic, VAX Basic, Visual Basic (&VBA).
>
> GOTO was deprecated before BBC Basic circa 1981. I never really saw it,
> apart from reasonable GOTO error usages. Wasn't it more a sign of lack
> of training than a linguistic feature?

I found a good way to use GOTO however - in a handheld
device where you had to enter several kinds of data
about a location. The structure was a sort of "ladder"
and pressing buttons would take you up and down the
ladder via GOTOs. If you needed to edit yer last entry
you just jumped one step up. The handheld only had a
4-line display alas, so you couldn't show even one
entire record, only one prompt at a time.

Now each entry was only a few lines of code - the input,
an error-detector and the up/down GOTO thing. Easy to
keep track of. GOTO made the pgm simpler and more
compact.

186282@ud0s4.net <186283@ud0s4.net> wrote:
> On 11/20/24 10:46 AM, Rich wrote:
>> 186282@ud0s4.net <186283@ud0s4.net> wrote:
>>> NEVER liked JS or Perl ... but that's just me.
>>> Real-world, they seem to do their thing OK.
>>
>> If JS or Perl are your yardstick for "never liked" you must never have
>> attempted to write an AutoHotKey script to automate something on a
>> windows machine.
>
> Tried a hotkey daemon once, DOS-era, but eventually
> bought one writ by better programmers. Automated
> Winders ... again a real pain in the ass. DOS was
> better at that.

Automating a GUI is usually a major PIA.

>> The entire language looks like three shit-faced drunk language
>> designers teamed up with three stoned off their gourd language
>> designers and agreed to create the script language, and each put in
>> their own alcohol or mary jane fueled idea of how the language
>> should be designed.
>>
>> There's absolutely no consistency in anything in that language. One
>> thing one has to pass around are WID's (Window ID's) so that the
>> target window which is to receive the "automation" is identified.
>> Some functions have prototypes like this (note, these are made up
>> below):
>>
>> getxy(wid, result)
>>
>> Others have prototypes like this:
>>
>> move_to_x_y(x, y, wid)
>>
>> Others are this way
>>
>> recolor-window(x, wid, y, color, result)
>>
>> Still others use camel case
>>
>> getSomethingFromWindows(result, a, b, wid, q)
>>
>> Note now "wid" moves around in the prototype list, yet it is needed for
>> nearly every call. Also note the underscore vs. hyphen vs camel case
>> names.
>
> I take it you're also not a fan of Perl :-)

I wrote my share of Perl in a world long ago. I never had the
visiceral reaction to it that some Perl haters have had however,

AutoHotKey, however, was another several orders of magnitude above
Perl. Perl is just filled with "special characters that have special
meanings", but the meanings are at least consistent. $ is always
'scalar', % is always key value map, etc. AutoHotKey, however, would
have had % mean seven different meanings in the seven different places
it might be used to mean something.

> Hey, working with X stuff you also need to identify
> screens sometimes ... and they're not always readily
> identified - <something>:2:2

That was a given. What was asinine was some functions expected "winid,
x, y" as parameter order, others wanted "x,y,winid", still others did
"x,winid,something, y" and still others wanted "y, something1, x,
something2, winid). There was no consistency, anywhere, with any order
of parameters or of what parameters were always present. It literally
was as if drunk and stoned designers just threw crap at a wall, and
whatever stuck to the wall became the AutoHotKey script language.

On Thu, 21 Nov 2024 08:09:29 +0000, Pancho wrote:

> GOTO was deprecated before BBC Basic circa 1981. I never really saw it,
> apart from reasonable GOTO error usages. Wasn't it more a sign of lack
> of training than a linguistic feature?

I never understood the goto hate that Dijkstra had. It could be used to
produce hideous code but has valid uses. I'm amused by the syntactic sugar
used by many languages to conceal what is obviously a goto under the hood
amd of you dig far enough you get down to JMP, JNE, and similar opcodes.

On 11/21/24 15:45, 186282@ud0s4.net wrote:
> On 11/21/24 3:09 AM, Pancho wrote:
>> On 11/20/24 21:05, Rich wrote:
>>> John Ames <commodorejohn@gmail.com> wrote:
>>>> On Wed, 20 Nov 2024 03:37:58 -0500
>>>> "186282@ud0s4.net" <186283@ud0s4.net> wrote:
>>>>
>>>>> Hmmmmmmmm ... how many now have EVER programmed in BASIC ? Should do
>>>>> a survey .....
>>>>
>>>> Lord, who hasn't!? Well, probably depends on how you choose to qualify
>>>> it - we still use VB6 in-house at $EMPLOYER, and FreeBASIC is my go-to
>>>> for hacking together quick utility applications in daily life, but I
>>>> haven't touched old-school line-number spaghetti-Gotoese BASIC since
>>>> childhood, and certainly never built any application of real complexity
>>>> with it. Bet more than a few people here have, though, especially if we
>>>> cross-posted over to a.f.computers...
>>>
>>> Given the typical age of most posters here, I'd say nearly every one of
>>> us has written /something/ in one or more of the 75 different variants
>>> of "BASIC" that have existed over time.
>>>
>>
>> For me: BBC Basic, VAX Basic, Visual Basic (&VBA).
>>
>> GOTO was deprecated before BBC Basic circa 1981. I never really saw
>> it, apart from reasonable GOTO error usages. Wasn't it more a sign of
>> lack of training than a linguistic feature?
>
>   I found a good way to use GOTO however - in a handheld
>   device where you had to enter several kinds of data
>   about a location. The structure was a sort of "ladder"
>   and pressing buttons would take you up and down the
>   ladder via GOTOs. If you needed to edit yer last entry
>   you just jumped one step up. The handheld only had a
>   4-line display alas, so you couldn't show even one
>   entire record, only one prompt at a time.
>
>   Now each entry was only a few lines of code - the input,
>   an error-detector and the up/down GOTO thing. Easy to
>   keep track of. GOTO made the pgm simpler and more
>   compact.

Sounds like a jump table. We still do that, but with functions rather
than jumps.

On 11/21/24 19:48, rbowman wrote:
> On Thu, 21 Nov 2024 08:09:29 +0000, Pancho wrote:
>
>> GOTO was deprecated before BBC Basic circa 1981. I never really saw it,
>> apart from reasonable GOTO error usages. Wasn't it more a sign of lack
>> of training than a linguistic feature?
>
> I never understood the goto hate that Dijkstra had. It could be used to
> produce hideous code but has valid uses. I'm amused by the syntactic sugar
> used by many languages to conceal what is obviously a goto under the hood
> amd of you dig far enough you get down to JMP, JNE, and similar opcodes.
>

Well obviously, a do while is a branch and a jump. The idea was not to
eliminate jumps but to impose a structure upon them. So much of good
programming is imposing structure, imposing good practice rules to make
the code more understandable, more manageable.

You can use good modern programming paradigms in C: OO, pure functions,
bounds checked arrays, and automatic memory deallocation, it is just
easier with languages which give you syntactic sugar, and specific
linguistic features.

On Thu, 21 Nov 2024 23:14:45 +0000, Pancho wrote:

> The idea was not to
> eliminate jumps but to impose a structure upon them. So much of good
> programming is imposing structure, imposing good practice rules to make
> the code more understandable, more manageable.

Also, when you have a lot of dynamic memory allocation going on, a
structured discipline helps reduce the chances of common errors like
double-frees or memory leaks.

<https://gitlab.com/ldo/a_structured_discipline_of_programming/>

On 11/21/24 6:04 PM, Pancho wrote:
> On 11/21/24 15:45, 186282@ud0s4.net wrote:
>> On 11/21/24 3:09 AM, Pancho wrote:
>>> On 11/20/24 21:05, Rich wrote:
>>>> John Ames <commodorejohn@gmail.com> wrote:
>>>>> On Wed, 20 Nov 2024 03:37:58 -0500
>>>>> "186282@ud0s4.net" <186283@ud0s4.net> wrote:
>>>>>
>>>>>> Hmmmmmmmm ... how many now have EVER programmed in BASIC ? Should do
>>>>>> a survey .....
>>>>>
>>>>> Lord, who hasn't!? Well, probably depends on how you choose to qualify
>>>>> it - we still use VB6 in-house at $EMPLOYER, and FreeBASIC is my go-to
>>>>> for hacking together quick utility applications in daily life, but I
>>>>> haven't touched old-school line-number spaghetti-Gotoese BASIC since
>>>>> childhood, and certainly never built any application of real
>>>>> complexity
>>>>> with it. Bet more than a few people here have, though, especially
>>>>> if we
>>>>> cross-posted over to a.f.computers...
>>>>
>>>> Given the typical age of most posters here, I'd say nearly every one of
>>>> us has written /something/ in one or more of the 75 different variants
>>>> of "BASIC" that have existed over time.
>>>>
>>>
>>> For me: BBC Basic, VAX Basic, Visual Basic (&VBA).
>>>
>>> GOTO was deprecated before BBC Basic circa 1981. I never really saw
>>> it, apart from reasonable GOTO error usages. Wasn't it more a sign of
>>> lack of training than a linguistic feature?
>>
>>    I found a good way to use GOTO however - in a handheld
>>    device where you had to enter several kinds of data
>>    about a location. The structure was a sort of "ladder"
>>    and pressing buttons would take you up and down the
>>    ladder via GOTOs. If you needed to edit yer last entry
>>    you just jumped one step up. The handheld only had a
>>    4-line display alas, so you couldn't show even one
>>    entire record, only one prompt at a time.
>>
>>    Now each entry was only a few lines of code - the input,
>>    an error-detector and the up/down GOTO thing. Easy to
>>    keep track of. GOTO made the pgm simpler and more
>>    compact.
>
> Sounds like a jump table. We still do that, but with functions rather
> than jumps.

In my app - and the people I wrote it for used it for
nearly a decade and could easily add/subtract bits - it
wasn't even a "table". The 'rungs on a ladder' was an
apt description.

GOSUBs and such are great, but in this case there
was less code/mem/cycles involved using the GOTOs
and the devices did NOT have much space for program.

Anyhow, that was my neatest use of GOTO. Nothing
really WRONG with such jumps, they're being done
in the background by other forking logic anyway,
it's just that if BADLY used you get unmaintainable
spaghetti code.

Even today, Free Pascal supports GOTO ... but you
LABEL the destination point so you don't have to
worry about changing line numbers like with older
versions of BASIC. FORTRAN did, some versions still
do, support I think two version of GO TO ... labeled
and 'calculated'. Sometimes you just CAN'T cleanly
structure what you want - and GOTO is a secret way
out of some deep deep if-then's and while's and such.

In any case - part of what I was wondering was
how many young coders have ever used BASIC, at
least for more than a few lines of VBA or whatever.
It used to be THE all-around computer language,
but that became Python instead.

The Natural Philosopher <tnp@invalid.invalid> writes:

> On 21/11/2024 07:20, 186282@ud0s4.net wrote:
>> I take it you're also not a fan of Perl  🙂
>
> Perfectly Execrable Rubbish Language

I've heard it called:

"Pathologically Eclectic Rubbish Lister"

--
-Don_from_AZ-

On Thu, 21 Nov 2024 20:31:11 -0500, 186282@ud0s4.net wrote:

> Even today, Free Pascal supports GOTO ... but you LABEL the
> destination point so you don't have to worry about changing line
> numbers like with older versions of BASIC. FORTRAN did, some versions
> still do, support I think two version of GO TO ... labeled and
> 'calculated'. Sometimes you just CAN'T cleanly structure what you
> want - and GOTO is a secret way out of some deep deep if-then's and
> while's and such.

The computer goto was declared 'obsolescent' in F95 in favor of 'case' but
afaik it still will compile.

Put enough lipstick on the pig and you wind up with a vtable.

On Thu, 21 Nov 2024 20:19:55 -0700, Don_from_AZ wrote:

> The Natural Philosopher <tnp@invalid.invalid> writes:
>
>> On 21/11/2024 07:20, 186282@ud0s4.net wrote:
>>>
>>> I take it you're also not a fan of Perl  🙂
>>
>> Perfectly Execrable Rubbish Language
>
> I've heard it called:
>
> "Pathologically Eclectic Rubbish Lister"

It changed the meaning of the term “high-level language” forever.

On 11/21/24 10:54 PM, rbowman wrote:
> On Thu, 21 Nov 2024 20:31:11 -0500, 186282@ud0s4.net wrote:
>
>> Even today, Free Pascal supports GOTO ... but you LABEL the
>> destination point so you don't have to worry about changing line
>> numbers like with older versions of BASIC. FORTRAN did, some versions
>> still do, support I think two version of GO TO ... labeled and
>> 'calculated'. Sometimes you just CAN'T cleanly structure what you
>> want - and GOTO is a secret way out of some deep deep if-then's and
>> while's and such.
>
> The computer goto was declared 'obsolescent' in F95 in favor of 'case' but
> afaik it still will compile.
>
> Put enough lipstick on the pig and you wind up with a vtable.

Heh !!! :-)

Well, I don't see FORTRAN as a "pig" really - a totally
useful, still well-supported, lang. Still do little FORTRAN
utils just to stay in practice.

Anyway, sometimes you have to nest/flag deep if/then's
and whiles and such so deep that there's really no
clean escape in a special or exception condition. This
is where a 'bail-out' GOTO or two can make yer code
a LOT simpler/smaller. Not 101% aesthetic, but it works
very well. Use conservatively.

Ultimately you judge code by what it DOES - less by
to how it "looks". It's all "working the machine".

On 11/21/24 6:50 PM, Lawrence D'Oliveiro wrote:
> On Thu, 21 Nov 2024 23:14:45 +0000, Pancho wrote:
>
>> The idea was not to
>> eliminate jumps but to impose a structure upon them. So much of good
>> programming is imposing structure, imposing good practice rules to make
>> the code more understandable, more manageable.
>
> Also, when you have a lot of dynamic memory allocation going on, a
> structured discipline helps reduce the chances of common errors like
> double-frees or memory leaks.
>
> <https://gitlab.com/ldo/a_structured_discipline_of_programming/>
>

Quite true. Dynamic alloc is powerful, but can also
be a powerful driver of horrible FAULTS. Gotta keep
close track !

But, if smart, less-structured CAN be made right.

Today, I'd rec "structured" for a number of reasons,
but we didn't always have that sort of luxury in
abundance.

Still don't love "object" ... gimme something closer
to K&R instead :-)

On 21/11/2024 19:48, rbowman wrote:
> On Thu, 21 Nov 2024 08:09:29 +0000, Pancho wrote:
>
>> GOTO was deprecated before BBC Basic circa 1981. I never really saw it,
>> apart from reasonable GOTO error usages. Wasn't it more a sign of lack
>> of training than a linguistic feature?
>
> I never understood the goto hate that Dijkstra had. It could be used to
> produce hideous code but has valid uses. I'm amused by the syntactic sugar
> used by many languages to conceal what is obviously a goto under the hood
> amd of you dig far enough you get down to JMP, JNE, and similar opcodes.
>
Yup.

The real hate was code that was hard to read and debug because flow
jumped about all over the place.

But you need to have conditional code execution and that means at some
level a goto, even if its implicit.

if(Bollocks)
{ // ELSE GOTO next '}'
blah();
}

--
Any fool can believe in principles - and most of them do!

On 21/11/2024 23:04, Pancho wrote:
> On 11/21/24 15:45, 186282@ud0s4.net wrote:
>> On 11/21/24 3:09 AM, Pancho wrote:
>>> On 11/20/24 21:05, Rich wrote:
>>>> John Ames <commodorejohn@gmail.com> wrote:
>>>>> On Wed, 20 Nov 2024 03:37:58 -0500
>>>>> "186282@ud0s4.net" <186283@ud0s4.net> wrote:
>>>>>
>>>>>> Hmmmmmmmm ... how many now have EVER programmed in BASIC ? Should do
>>>>>> a survey .....
>>>>>
>>>>> Lord, who hasn't!? Well, probably depends on how you choose to qualify
>>>>> it - we still use VB6 in-house at $EMPLOYER, and FreeBASIC is my go-to
>>>>> for hacking together quick utility applications in daily life, but I
>>>>> haven't touched old-school line-number spaghetti-Gotoese BASIC since
>>>>> childhood, and certainly never built any application of real
>>>>> complexity
>>>>> with it. Bet more than a few people here have, though, especially
>>>>> if we
>>>>> cross-posted over to a.f.computers...
>>>>
>>>> Given the typical age of most posters here, I'd say nearly every one of
>>>> us has written /something/ in one or more of the 75 different variants
>>>> of "BASIC" that have existed over time.
>>>>
>>>
>>> For me: BBC Basic, VAX Basic, Visual Basic (&VBA).
>>>
>>> GOTO was deprecated before BBC Basic circa 1981. I never really saw
>>> it, apart from reasonable GOTO error usages. Wasn't it more a sign of
>>> lack of training than a linguistic feature?
>>
>>    I found a good way to use GOTO however - in a handheld
>>    device where you had to enter several kinds of data
>>    about a location. The structure was a sort of "ladder"
>>    and pressing buttons would take you up and down the
>>    ladder via GOTOs. If you needed to edit yer last entry
>>    you just jumped one step up. The handheld only had a
>>    4-line display alas, so you couldn't show even one
>>    entire record, only one prompt at a time.
>>
>>    Now each entry was only a few lines of code - the input,
>>    an error-detector and the up/down GOTO thing. Easy to
>>    keep track of. GOTO made the pgm simpler and more
>>    compact.
>
> Sounds like a jump table. We still do that, but with functions rather
> than jumps.
>
Case statements...

--
For in reason, all government without the consent of the governed is the
very definition of slavery.

Jonathan Swift

The Natural Philosopher <tnp@invalid.invalid> writes:
> On 21/11/2024 19:48, rbowman wrote:
>> I never understood the goto hate that Dijkstra had. It could be used
>> to produce hideous code but has valid uses. I'm amused by the
>> syntactic sugar used by many languages to conceal what is obviously a
>> goto under the hood amd of you dig far enough you get down to JMP,
>> JNE, and similar opcodes.
>
> Yup.
>
> The real hate was code that was hard to read and debug because flow
> jumped about all over the place.
>
> But you need to have conditional code execution and that means at some
> level a goto, even if its implicit.
>
> if(Bollocks)
> { // ELSE GOTO next '}'
> blah();
> }

Dijkstra’s complaints were about the difficulty of understanding code
made of a spaghetti heap of explicit gotos. He was quite happy with
if/while/etc - his complaint is certainly not about conditional
execution etc.

He didn’t model the higher-level constructions in terms of implicit
gotos but that’s not really relevant to general discussion.

The one place I’ll use a goto (in C) is to branch to unified cleanup
code in an error case, usually using a macro both to emphasize what’s
going on and to stop the error-handling guff from dominating what the
reader sees.

For selective, conditional and repeated execution there are generally
cleaner ways to write it, and use of gotos for these purposes is
generally a hint that the code needs some work. More recent languages
have other options (‘defer’, ‘finally’, destructors, etc).

--
https://www.greenend.org.uk/rjk/

On 22/11/2024 10:45, Richard Kettlewell wrote:
> The one place I’ll use a goto (in C) is to branch to unified cleanup
> code in an error case, usually using a macro both to emphasize what’s
> going on and to stop the error-handling guff from dominating what the
> reader sees.
>
+1
GOTO snafu_nuclear_option... :-)

> For selective, conditional and repeated execution there are generally
> cleaner ways to write it, and use of gotos for these purposes is
> generally a hint that the code needs some work. More recent languages
> have other options (‘defer’, ‘finally’, destructors, etc).
>
+2
> --

--
Socialism is the philosophy of failure, the creed of ignorance and the
gospel of envy.

Its inherent virtue is the equal sharing of misery.

Winston Churchill

On 11/22/24 10:35, The Natural Philosopher wrote:
> On 21/11/2024 23:04, Pancho wrote:
>> On 11/21/24 15:45, 186282@ud0s4.net wrote:
>>> On 11/21/24 3:09 AM, Pancho wrote:
>>>> On 11/20/24 21:05, Rich wrote:
>>>>> John Ames <commodorejohn@gmail.com> wrote:
>>>>>> On Wed, 20 Nov 2024 03:37:58 -0500
>>>>>> "186282@ud0s4.net" <186283@ud0s4.net> wrote:
>>>>>>
>>>>>>> Hmmmmmmmm ... how many now have EVER programmed in BASIC ? Should do
>>>>>>> a survey .....
>>>>>>
>>>>>> Lord, who hasn't!? Well, probably depends on how you choose to
>>>>>> qualify
>>>>>> it - we still use VB6 in-house at $EMPLOYER, and FreeBASIC is my
>>>>>> go-to
>>>>>> for hacking together quick utility applications in daily life, but I
>>>>>> haven't touched old-school line-number spaghetti-Gotoese BASIC since
>>>>>> childhood, and certainly never built any application of real
>>>>>> complexity
>>>>>> with it. Bet more than a few people here have, though, especially
>>>>>> if we
>>>>>> cross-posted over to a.f.computers...
>>>>>
>>>>> Given the typical age of most posters here, I'd say nearly every
>>>>> one of
>>>>> us has written /something/ in one or more of the 75 different variants
>>>>> of "BASIC" that have existed over time.
>>>>>
>>>>
>>>> For me: BBC Basic, VAX Basic, Visual Basic (&VBA).
>>>>
>>>> GOTO was deprecated before BBC Basic circa 1981. I never really saw
>>>> it, apart from reasonable GOTO error usages. Wasn't it more a sign
>>>> of lack of training than a linguistic feature?
>>>
>>>    I found a good way to use GOTO however - in a handheld
>>>    device where you had to enter several kinds of data
>>>    about a location. The structure was a sort of "ladder"
>>>    and pressing buttons would take you up and down the
>>>    ladder via GOTOs. If you needed to edit yer last entry
>>>    you just jumped one step up. The handheld only had a
>>>    4-line display alas, so you couldn't show even one
>>>    entire record, only one prompt at a time.
>>>
>>>    Now each entry was only a few lines of code - the input,
>>>    an error-detector and the up/down GOTO thing. Easy to
>>>    keep track of. GOTO made the pgm simpler and more
>>>    compact.
>>
>> Sounds like a jump table. We still do that, but with functions rather
>> than jumps.
>>
> Case statements...
>
In OO, switch/case statements were deprecated too :-) I can't remember
exactly why. I think it was because we were supposed to use polymorphism
instead.

In practical project terms, giant switch statements were a pain in the
bum, because everyone would constantly be modifying that bit of code and
you would get source code merge conflicts.

It's coming back to me, VAX BASIC programs would be designed to consist
of a massive "do processing" loop, which would consist of a big switch
statement containing a case for every type of report or behaviour the
program was supposed to handle. Every time a new report was added, the
switch had a case added.

Then it reminds me of the Gang of Four visitor pattern, every time I saw
it, it took me a whole morning's thinking energy to understand that it
was just a simple switch :-).

Coding is always a balance between flexibility and clarity, there is no
"right" answer. You can make code more flexible by adding another layer
of indirection, but it becomes harder to understand.

On 2024-11-22, The Natural Philosopher <tnp@invalid.invalid> wrote:

> On 22/11/2024 10:45, Richard Kettlewell wrote:
>
>> The one place I’ll use a goto (in C) is to branch to unified cleanup
>> code in an error case, usually using a macro both to emphasize what’s
>> going on and to stop the error-handling guff from dominating what the
>> reader sees.
>
> +1
> GOTO snafu_nuclear_option... :-)

All my programs contain a routine called quit_cleanup(); it takes
a single argument, which is either an error message or NULL.
It frees all allocated memory, closes any open files, etc.
(all such variables are global and I initialize them to NULL
or whatever other value is appropriate). Then, if the error
message argument is not NULL, it displays and/or logs the
message and calls exit() with a non-zero argument. If the
error message argument is NULL, it simply calls exit(0).
I can call it from anywhere, and it guarantees an orderly shutdown.

--
/~\ Charlie Gibbs | Growth for the sake of
\ / <cgibbs@kltpzyxm.invalid> | growth is the ideology
X I'm really at ac.dekanfrus | of the cancer cell.
/ \ if you read it the right way. | -- Edward Abbey

On 2024-11-22, 186282@ud0s4.net <186283@ud0s4.net> wrote:

> Anyhow, that was my neatest use of GOTO. Nothing
> really WRONG with such jumps, they're being done
> in the background by other forking logic anyway,
> it's just that if BADLY used you get unmaintainable
> spaghetti code.

The undisciplined use of subroutine calls can be as bad as
the undisciplined use of GOTOs. It's still spaghetti code,
only now the strands are doubled. After all, what is a
subroutine call other than a GOTO paired with a "come from"?

--
/~\ Charlie Gibbs | Growth for the sake of
\ / <cgibbs@kltpzyxm.invalid> | growth is the ideology
X I'm really at ac.dekanfrus | of the cancer cell.
/ \ if you read it the right way. | -- Edward Abbey

On 22/11/2024 13:37, Pancho wrote:
> On 11/22/24 10:35, The Natural Philosopher wrote:
>> On 21/11/2024 23:04, Pancho wrote:
>>> On 11/21/24 15:45, 186282@ud0s4.net wrote:
>>>> On 11/21/24 3:09 AM, Pancho wrote:
>>>>> On 11/20/24 21:05, Rich wrote:
>>>>>> John Ames <commodorejohn@gmail.com> wrote:
>>>>>>> On Wed, 20 Nov 2024 03:37:58 -0500
>>>>>>> "186282@ud0s4.net" <186283@ud0s4.net> wrote:
>>>>>>>
>>>>>>>> Hmmmmmmmm ... how many now have EVER programmed in BASIC ?
>>>>>>>> Should do
>>>>>>>> a survey .....
>>>>>>>
>>>>>>> Lord, who hasn't!? Well, probably depends on how you choose to
>>>>>>> qualify
>>>>>>> it - we still use VB6 in-house at $EMPLOYER, and FreeBASIC is my
>>>>>>> go-to
>>>>>>> for hacking together quick utility applications in daily life, but I
>>>>>>> haven't touched old-school line-number spaghetti-Gotoese BASIC since
>>>>>>> childhood, and certainly never built any application of real
>>>>>>> complexity
>>>>>>> with it. Bet more than a few people here have, though, especially
>>>>>>> if we
>>>>>>> cross-posted over to a.f.computers...
>>>>>>
>>>>>> Given the typical age of most posters here, I'd say nearly every
>>>>>> one of
>>>>>> us has written /something/ in one or more of the 75 different
>>>>>> variants
>>>>>> of "BASIC" that have existed over time.
>>>>>>
>>>>>
>>>>> For me: BBC Basic, VAX Basic, Visual Basic (&VBA).
>>>>>
>>>>> GOTO was deprecated before BBC Basic circa 1981. I never really saw
>>>>> it, apart from reasonable GOTO error usages. Wasn't it more a sign
>>>>> of lack of training than a linguistic feature?
>>>>
>>>>    I found a good way to use GOTO however - in a handheld
>>>>    device where you had to enter several kinds of data
>>>>    about a location. The structure was a sort of "ladder"
>>>>    and pressing buttons would take you up and down the
>>>>    ladder via GOTOs. If you needed to edit yer last entry
>>>>    you just jumped one step up. The handheld only had a
>>>>    4-line display alas, so you couldn't show even one
>>>>    entire record, only one prompt at a time.
>>>>
>>>>    Now each entry was only a few lines of code - the input,
>>>>    an error-detector and the up/down GOTO thing. Easy to
>>>>    keep track of. GOTO made the pgm simpler and more
>>>>    compact.
>>>
>>> Sounds like a jump table. We still do that, but with functions rather
>>> than jumps.
>>>
>> Case statements...
>>
> In OO, switch/case statements were deprecated too :-) I can't remember
> exactly why. I think it was because we were supposed to use polymorphism
> instead.
>
> In practical project terms, giant switch statements were a pain in the
> bum, because everyone would constantly be modifying that bit of code and
> you would get source code merge conflicts.
>
> It's coming back to me, VAX BASIC programs would be designed to consist
> of a massive "do processing" loop, which would consist of a big switch
> statement containing a case for every type of report or behaviour the
> program was supposed to handle. Every time a new report was added, the
> switch had a case added.
>
> Then it reminds me of the Gang of Four visitor pattern, every time I saw
> it, it took me a whole morning's thinking energy to understand that it
> was just a simple switch :-).
>
> Coding is always a balance between flexibility and clarity, there is no
> "right" answer. You can make code more flexible by adding another layer
> of indirection, but it becomes harder to understand.
>
>
I echo that. The 'nogoto' was really a fool's rule. The wise man's
guidance was 'make it clear what you are doing because you or someone
else - may need to understand it in a years time'
I dpnt find OO in general makes code easier to understand.

>
>
>

--
Of what good are dead warriors? … Warriors are those who desire battle
more than peace. Those who seek battle despite peace. Those who thump
their spears on the ground and talk of honor. Those who leap high the
battle dance and dream of glory … The good of dead warriors, Mother, is
that they are dead.
Sheri S Tepper: The Awakeners.

Rich <rich@example.invalid> wrote at 02:48 this Thursday (GMT):
> candycanearter07 <candycanearter07@candycanearter07.nomail.afraid> wrote:
>> Rich <rich@example.invalid> wrote at 21:05 this Wednesday (GMT):
>>> John Ames <commodorejohn@gmail.com> wrote:
>>>> On Wed, 20 Nov 2024 03:37:58 -0500
>>>> "186282@ud0s4.net" <186283@ud0s4.net> wrote:
>>>>
>>>>> Hmmmmmmmm ... how many now have EVER programmed in BASIC ?
>>>>> Should do a survey .....
>>>>
>>>> Lord, who hasn't!? Well, probably depends on how you choose to
>>>> qualify it - we still use VB6 in-house at $EMPLOYER, and FreeBASIC
>>>> is my go-to for hacking together quick utility applications in
>>>> daily life, but I haven't touched old-school line-number
>>>> spaghetti-Gotoese BASIC since childhood, and certainly never built
>>>> any application of real complexity with it. Bet more than a few
>>>> people here have, though, especially if we cross-posted over to
>>>> a.f.computers...
>>>
>>> Given the typical age of most posters here, I'd say nearly every one
>>> of us has written /something/ in one or more of the 75 different
>>> variants of "BASIC" that have existed over time.
>>
>> I haven't
>
> Which would make you a member of the remainder of "nearly every" (which
> does not encompass "all").
>
> It would also imply that you /may/ be one of the younger members posting
> in the group.

Yeah, probably one of the youngest.
--
user <candycane> is generated from /dev/urandom

Charlie Gibbs <cgibbs@kltpzyxm.invalid> wrote at 18:53 this Friday (GMT):
> On 2024-11-22, The Natural Philosopher <tnp@invalid.invalid> wrote:
>
>> On 22/11/2024 10:45, Richard Kettlewell wrote:
>>
>>> The one place I’ll use a goto (in C) is to branch to unified cleanup
>>> code in an error case, usually using a macro both to emphasize what’s
>>> going on and to stop the error-handling guff from dominating what the
>>> reader sees.
>>
>> +1
>> GOTO snafu_nuclear_option... :-)
>
> All my programs contain a routine called quit_cleanup(); it takes
> a single argument, which is either an error message or NULL.
> It frees all allocated memory, closes any open files, etc.
> (all such variables are global and I initialize them to NULL
> or whatever other value is appropriate). Then, if the error
> message argument is not NULL, it displays and/or logs the
> message and calls exit() with a non-zero argument. If the
> error message argument is NULL, it simply calls exit(0).
> I can call it from anywhere, and it guarantees an orderly shutdown.

Unless you specifically use your own allocation wrapper that adds it to
an internal list, how do you deallocate "all" the allocations you've
done?
--
user <candycane> is generated from /dev/urandom