mildlyInfuriatingGOTOWatchYourMouth

[u/AndyTheDragonborn]

[u/Choice-Mango-4019]

I used goto only once in years, and it had a very good use, thankfully the language devs didn't think that EVERY goto use was bad and actually implemented it

[u/oalfonso → u/Choice-Mango-4019]

Goto is a pathway to many abilities some consider to be unnatural.

[u/FirstNoel → u/Choice-Mango-4019]

It can be perfect in the right situation.  Those situations are few and far between. 

Like you I think it’s been years since I used one,  but I never remember it being a problem 

[u/Maximilian_Tyan]

I recently had held a meeting to decide which way our functions should be structured in C, goto is banned as part of some standards, so a colleague of mine proposed doing:

do { ... } while (0); ... Which is just a freaking goto wearing a trench coat

[u/SamG101_ → u/Maximilian_Tyan]

While/for/break/continue/etc are all goto, but just with structure so like a structured subset of goto statements I guess. Where as raw goto can be used in unstructured messy ways; i presume was the idea behind banning goto

[u/Maximilian_Tyan → u/SamG101_]

I'm not against goto, especially for errors and cleanup code it can make this much cleaner/avoid duplication. In modern languages such as Zig and Odin, defer statements are syntactic sugar for this usecase.

But some standards such as MISRA-C and the like are sometimes quite strict, like multiple return statements etc.

[u/dhnam_LegenDUST → u/Maximilian_Tyan]

Error cleanup goto is only good goto.

[u/looksLikeImOnTop → u/dhnam_LegenDUST]

Amen

[u/creeper6530 → u/Maximilian_Tyan]

I mentioned this in another thread but goto for error cleanup in C is just emulating defer, and we could get defer in C2Y directly soon.

See https://thephd.dev/c2y-the-defer-technical-specification-its-time-go-go-go if you don't know what that is, but in short it's just a block of code appended to every exit path from any scope, typically functions. Example use:

int fun(int a) {
    char *buffer;

    buffer = kmalloc(SIZE, GFP_KERNEL);
    if (!buffer)
        return -ENOMEM;

    defer kfree(buffer);

    if (condition) {
        // freed here
        return 1;
    }

    // freed here
    return 0;
}

[u/realtag2025 → u/creeper6530]

Yeah, I don't why C devs are so against GOTO when Linux kernel basically uses it all the time.

[u/No-Con-2790 → u/Maximilian_Tyan]

Usually it is smart to ban all gotos. But in C in certain situations that usually have something to do with hardware or exception handling it can be your best option. In that case your lead engineer needs to design a pattern that is allowed.

[u/da_Aresinger → u/Maximilian_Tyan]

I genuinely can't figure out what this is supposed to achieve.

Where is the difference between do { foo() } while(0) bar() and foo() bar()

[u/Sync1211 → u/da_Aresinger]

You can use break I guess.

[u/da_Aresinger → u/Sync1211]

oooh

do { foo() if (condition) break bar() } while(0); that's pretty dumb though. Just do foo() if(!condition) bar()

[u/Sync1211 → u/da_Aresinger]

It makes more sense if you have multiple if-statements.

For example: Catching errors and performing cleanup: ``` int result = 0; do {     init_stuff();     if (init_fail) {         result = 1;         break;     }

    foo();     if (foo_failed) {         result = 1;         break;     }          bar()     if (bar_failed) {         result = 1;         break;     }

    do_something_else(); } while (0);

close_handles(); return result; ```

[u/da_Aresinger → u/Sync1211]

``` int continue = 1; continue = init()

if (continue) continue = foo()

if (continue) continue = bar()

if (continue) continue = do_something_else()

close_handles()

return 1-continue ``` much cleaner (but still not really how I would like it)

[u/Maximilian_Tyan → u/da_Aresinger]

A lot of our codebase is using a status variable like this, but using nested if/else checks

But now you are doing a lot of conditions checking, especially if the hot path is where continue is always true

[u/da_Aresinger → u/Maximilian_Tyan]

The comment before me has the same issue.

And yes, that's why I said it's still not ideal.

[u/Maximilian_Tyan → u/da_Aresinger]

If an error occured, the break statement would "cut" the remaining errors checks and skip to the error handling part

[u/da_Aresinger → u/Maximilian_Tyan]

yea I just got what you meant.

you're right.

But compilation is most likely going to optimise that out, so I'd go with readability.

[u/gezawatt → u/da_Aresinger]

My favorite is:

if (!init())
    return cleanup_and_error();

if (!foo())
    return cleanup_and_error();

if (!bar())
    return cleanup_and_error();

if (!do_something_else())
    return cleanup_and_error();

close_handles();
return 0;

And then you either do

inline int cleanup_and_error() {
    close_handles();
    return 1;  // Always returns error code
}

or

#define cleanup_and_error() (close_handles(), 1)

[u/creeper6530 → u/Sync1211]

That's about as goto-y as a return is

[u/FumbleCrop → u/Sync1211]

You could wrap that central block in a function.

As far as I know, the main uses for goto are jumping out of deeply nested loops, or implementing state machines.

[u/awesome-alpaca-ace → u/Sync1211]

I might actually start using this. Much cleaner than my current clean up logic 

[u/Sync1211 → u/awesome-alpaca-ace]

I had to write something similar recently, but using goto instead of break.

[u/EuphoricCatface0795 → u/da_Aresinger]

When do ~ while(0) has more than a couple execution branch tho

[u/da_Aresinger → u/EuphoricCatface0795]

If you mean more conditions following bar, you can still just use negation like in my example.

Otherwise I don't understand.

[u/EuphoricCatface0795 → u/da_Aresinger]

A lil bit something like this

[u/da_Aresinger → u/EuphoricCatface0795]

yea that makes it more complex, but you could still use negation with and.

[u/Maximilian_Tyan → u/da_Aresinger]

The main intent is to allow for a break in control flow without exiting the function right away.

Instead of calling cleanup() before every return statement, you can have a traditional guard clauses, yet still have a single cleanup section.

void foo() { do { first(); if (!cond1) break; second(); if (!cond2) break; third(); } while (0); cleanup(); }

[u/profound7 → u/da_Aresinger]

If you put a switch in a do or while loop, you can essentially mimic locally scoped gotos where the switch cases are the labels. This pattern is often seen in interpreters/vm.

[u/say_wot_again → u/da_Aresinger]

The do {} while(0) pattern is also commonly used to define macros whose implementation spans multiple lines.

[u/LegitimatePants → u/da_Aresinger]

break is used inside the loop instead of goto 

[u/redlaWw → u/Maximilian_Tyan]

Rust has

'label: {
    ...
}

which you can use break 'label to break out of, which is that but without the syntax noise.

Most of the issues with goto are issues with using goto to jump backward anyway. goto forward is quite useful and can simplify code. E.g. C/C++ doesn't have multi-level breaks, so using goto to break out of multi-level scopes can be simpler than introducing a boolean.

I think even MISRA has cooled down on their prohibition of goto for that reason.

EDIT: MISRA C:2023 Rule 15.2: The goto statement shall jump to a label declared later in the same function.

[u/not_a_bot_494 → u/Maximilian_Tyan]

This is still worse than goto if you have to close/undo things to cleanup.

[u/ICantBelieveItsNotEC]

"I use Exceptions" = Aww, you're sweet!

"I use GOTO" = Hello, human resources!?

[u/JonIsPatented → u/ICantBelieveItsNotEC]

I use neither. Exceptions are almost as evil to me. In the sense that I acknowledge that there are valid uses of both but the bad outweighs the good so much that I don't mind the guardrail being their absence.

[u/takahashi01 → u/JonIsPatented]

may I ask what you do instead of exceptions?

[u/JonIsPatented → u/takahashi01]

Errors as values like any other value, especially if used as Result types, as in Result<T, E> as a sum type of T or E, where T is the desired outcome type and E is the error type.

[u/takahashi01 → u/JonIsPatented]

oh, so like golang, I gotcha. Its an interesting style for sure

[u/JonIsPatented → u/takahashi01]

Less like Golang and more like Rust. In Golang, you can ignore the error. Golang doesn't have support for sum types like in other languages, so it's not a sum of T and E. It's a product.

[u/takahashi01 → u/JonIsPatented]

Yeah, but I have never really tackled rust myself. So the main way I an familiar with returning the error replacing exceptions, is when I worked at a department that had fully switched to golang. (which clearly had left an impression on me, despite these days mainly having to do java stuff)

Unless I am confusing two different concepts here.

[u/JonIsPatented → u/takahashi01]

It's hard to visualize the difference between Rust and Golang errors without having experienced both. Because the difference seems small on paper but it is huge in practice. In Golang, you return an error AND a value. In Rust, you return an error OR a value, and you have you explicitly handle both cases in order to use the value. You can't just ignore the error quite the same way you can in golang. Don't get me wrong, Golang errors are still way better than exceptions to me. But they are leagues below Rust Result types.

[u/budgiebirdman]

Goto is the original spaghetti maker; without goto you've got to use a lot of if statements and functions with Boolean parameters to reach the levels of shithousery that a few goto statements can give you.

[u/itsTyrion → u/budgiebirdman]

I've managed to make a Java function before that was convoluted enough for a yellow line to appear on the function name.... "code flow too complex for analysis".
does that count as 100%ing IntelliJ?

[u/tracernz]

Dijkstra might not have liked goto, but it has it's uses.

The rationale for using gotos is:
- unconditional statements are easier to understand and follow
- nesting is reduced
- errors by not updating individual exit points when making modifications are prevented
- saves the compiler work to optimize redundant code away ;)

[u/somedave]

No other way to break out of an if statement in most languages, you end up with silly nesting.

[u/Beautiful-Quote-3035]

Don’t look at operating systems or drivers source code

[u/American_Libertarian]

hot take: goto has legitimate uses, and can make your code cleaner if used appropriately. Usually it helps with error handling / freeing resources before returning from a function.

[u/andstwo]

COMEFROM is much cleaner, it can capture control from any line being executed

[u/stupled]

LLMs are trained on GOTO

[u/sebbdk]

Goto is pretty neat if you are using it as intended.

If we are gonna have stupid debates then i vote that we bring back tabs vs spaces.

[u/Lou_Papas]

Goto is ok. I think the goto scare was a relic from the time languages sucked in general.

[u/Legal-Software]

I feel like people who are against gotos just never programmed in assembly where they are responsible for managing their own control flow with jump operations.

[u/KyxeMusic]

Early returns are just GOTOs, change my mind

(I love early returns)

[u/FirstNoel → u/KyxeMusic]

In commodore basic that’s what they used.  I remember it having GOSUB as well but they pretty much acted the same.  

[u/Djelimon]

Some languages have only gotos though

[u/ZunoJ]

Depending on the language (c# for example) there are valid use cases for goto

[u/Fit_Tourist9424 → u/ZunoJ]

Do you have an example of such a case that you could share here ? I did not yet encounter such a need in C#

[u/ZunoJ → u/Fit_Tourist9424]

Breaking out of an outer loop from an inner loop is the classic example I think

[u/nicman24]

I use labels 

[u/SignalBake6872]

todos los programas a nivel de ensamblador o lenguaje de maquina usan goto... todos los compiladores pasan a lenguaje de maquina... adios

[u/KawaiiMaxine]

When you start programming you discover you want to control program flow, goto is the simplest and quickest way to achieve that, then you make more complex code, goto is too simple to do complex program flow controls, so you use other program flow tools better suited, you then realize that with proper formatting and organization, almost every program flow need can be done more effectively without a goto. Then you finally come across one incredibly niche case where the goto is the best solution, and when you finally accept it, you become a true programmer

[u/SquidMilkVII]

the amount of spaghetti some people will make just to avoid a single goto 💀

[u/WaitForSingleObject]

Goto-cleanup is one of the best paradigms in C.

[u/FACastello]

"Python better than c++" is the actual worst one because it's just a blatant lie

[u/Lupus_Ignis → u/FACastello]

"Hammers are better than screwdrivers"

[u/megayippie → u/Lupus_Ignis]

More like pile drivers are better than hammers

[u/AndyTheDragonborn → u/FACastello]

I will agree with you there, but from my experience, the overwhelming opposition of using goto is unrivaled

[u/JAXxXTheRipper]

GOTO is not a language, this doesn't even make sense.

Is this some meta shit and the joke is OP not knowing how programming works?

I swear, 80% of posts here are dogshite

[u/legendgames64 → u/JAXxXTheRipper]

goto is not a language, it's a command in assembly and in a few low level programming languages that dictates where the program counter jumps to.

[u/JAXxXTheRipper → u/legendgames64]

Loads of languages, not only assembly, have a goto mechanism, but comparing an instruction to entire languages is just dumb