Explain what's wrong with it without sounding mad.

nothing, some midwit college teacher/prof told someone that it's one of the >le bad programming practices and that they should clean their code and wash their penis and clean their room (if you know you know)
aside from that there's nothing wrong with it and people who criticize it are either unemployed or have never written a signifanct piece of software, ever

because there are zero conditions to it. it doesn't matter what the scope is, or what's being done. it will immediately shift control. you could be initializing a constructor and it will shift control. you could be allocating memory and it will shift control. you could be rearranging the stack and it will shift control. all immediately when the previous instruction is sent, not after it's done.

It makes the code harder to read. You will forget what the code does a week later.

>>106167315
>>106167326

>>106167245 (OP)
Isn't this just like a JMP instruction?
>Assembly is problematic

>>106167245 (OP)
its easy to turn your code into spaghetti with it
its not something wrong with the statement per se, just that it has a barrier of entry to it

>>106167245 (OP)
It makes encapsulation and complexity management impossible. People who advocate for its use outside of specific low-level contexts are universally retarded junior no-coders who have never touched anything more complicated than a cli calculator tutorial.

the entire point of using a programming language is to give some sort of meaningful structure to your program, as soon as you start gotoing all over the place the structure imposed by the language is destroyed

>>106167378
>impossible
no

>>106167378
>retarded
ad hominim

everyone misses the mark

goto makes code hard to read. that's it. the actual problem.

>>106167315
goto in modern languages is a structured concept. Its perfectly safe. You cannot jump out of a function. Goto is no worse than break or continue.

>>106167378
>oop concerns
>in c
...
>>106167394
>goto makes code hard to read. that's it. the actual problem.
it doesnt and it prevents code duplication when used wisely >>106167359
it just has a barrier of entry to it
but so does C

>>106167394
> goto makes code hard to read
Goto a tool that has its uses. What is more unreadable than goto is the contortions people make to avoid using it.

>>106167245 (OP)
The only time I have ever used it is for error handling, I don't know what any other practical use case would be for it.

>>106167245 (OP)
Nothing if you have a legitimate reason to use it, like any other code features.
Historically it's been an aggravating factor in sloppy code, giving it a bad reputation, but the code would've been bad regardless of if it used goto or not.

>>106167245 (OP)
nothing

>but you can complicate flow control and make code impossible to maintain
you can do that anyway, you don’t need goto to make a fucked up mess. like any other tool, when you don’t abuse it there is no issue

>>106167453
i had one instance when i used it in a convoluted control flow situation, to short out of a loop. in ~300 klocs of code.
so i would expect to see it in optimization too
otherwise yeah, error handling

It's shit

>>106167245 (OP)
It's no longer necessary

>>106167245 (OP)
https://www.youtube.com/watch?v=mrY6xrWp3Gs

>>106167563
while(1) {
while(1) {
if (condition) {
goto exit;
}
}
}
exit:
Now what?

goto is an unconditional branch. in high level languages they break the flow of a program and makes it challenging to read. i think the only okay example is breaking both loops of a nested loop. they can be avoided, and any performance they provide is negligible.

>>106167656
>in high level languages they break the flow of a program and makes it challenging to read
high level languages do that all the time anyway with things like destructors and exceptions

>>106167267
>wash their penis
they would never say this, they would push circumcision instead because they are jewish

>>106167636
More languages should be like java.
outer:
while(true) {
while(true) {
if (condition) {
break outer;
}
}
}

>>106167315
don't use it like a retard then?

There is ABSOLUTELY NOTHING WRONG with forward goto jumps. You can't even create spaghetti with forward goto jumps. Very useful for error handling, or the inverse, skipping an error placed right after a search-loop.
Jumping back though? That we don't do. Can anyone even come up with something that's not just a bad version of some other control primitive? I'm genuinely curious.

>>106167245 (OP)
djkstra did real damage to programming, he wasn't even a real dev himself as he hated anything non-theorical, why the fuck are we still haunted by his retarded ghost...

>>106167394
>goto makes code hard to read. that's it. the actual problem.
how is it any different from a function call? you'll need to jump to it to read the code anyways except it's usually a few lines later and not in another file or in some .so you don't have the sources for

>>106167245 (OP)
Perfectly acceptable, Dijkstra was well known flame languages, including the ones he was involved in.
Like a PHD paper, the professors pretended to know their stuff by using references and harmful goto, spread across the academic world.

>>106167636
>while(1) {
> while(1) {
the code of goto proponents, everyone

>>106167708
how about i use you like a faggot?

>>106167740
>how is it any different from a function call?
a function returns to where it was called from. when reading code, you can skip over functions you don't need to inspect
goto is a one-way indirection - you *have* to inspect where the code jumps to if it gets executed

>>106167748
>program loop
>event loop
>goto is for when you want to close the program
makes sense to me

>>106167245 (OP)
goto is good for breaking out of nested loops
can be used as alternative to early return technique or when the language forces single return functions
can be used to directly go to cleanup section and might be or not a cleaner than a function call
can be used as more flexible switch using more than one variable for dispatch
there is nothing wrong with goto and people that do say so are just clueless cargo cult sheeps

>>106167392
RUUFF RUUUFFFF RUFF WOOOFF WOOF
RUFF

>>106167801
>goto is a one-way indirection - you *have* to inspect where the code jumps to if it gets executed
so? the goto is scoped local to the function, it’s not a long jump. if you’re reading the function you’re reading the function

>>106167563
>Be Sundar Pichai
>A walking piece of shit
>Best practice exists
>It's no longer necessary

>>106167394
>ad hominim
sigh... NTA, but that was an insult, not ad hominem.
Insults aren't necessarily ad hominem. It only becomes ad hominem when it's used as an excuse to dismiss a point someone is making.
Which the other poster wasn't doing.
Pet peeve of mine.
https://laurencetennant.com/bonds/adhominem.html

>>106167890
They're useful for breaking out of search loops too like this on success:
u32 i = 0;
for (; i < LENGTH(haystack); i++) {
if (needle == haystack[i]) goto found;
}
panic("Not found");
found:
// haystack[i] is our needle

>>106167973
NO, STOP THIS IS TOO HARD FOR ME TO READ ….UGH UH THE CONTROL FLOW, ITS ALL WRONG

if(teacher.type == poo)
goto toilet;
else
return;

toilet:
flush();

Number 1 wipe away, number 2 flush your poo.
Always flush your poos.

>>106167858
>program loop and event loop in a single function
it's either fizzbuzz-tier trivial, or severely unstructured and technically indebted

Test

>>106167984
What's wrong with it?

>um it's bad because you have to jump around in the code and that's bad
oh yeah? where are your functions? where are your methods stored? YOU ARE ALREADY JUMPING
YOU ARE ALREADY A JUMPER

>>106167740
You can write unit tests for a function, can't do that with a goto.

>>106167925
>if you’re reading the function you’re reading the function
no, because the linearity of reading line after line is still ruined

>>106167801
>you can skip over functions you don't need to inspect
same as goto then, why would you need to read the goto but not hte function if you want to read the code, it's the same fucking thing
>>106168052
lmao why would you write a unit test for a sugar coated if?

>>106168085
Because I'm assuming this is a real code-base and there's 500 lines of code between the goto and the label.

>>106167973
>>106167245 (OP)
you guys are retarded
you are using the specific cases where it's acceptable by EVERYONE to use goto and pretend you are so special for using it

but 99% of the times there are cleaner alternatives

and the fucking reason why profs say goto is le bad, is not for your 1 specific case which is good, but for the other 99% cases where programmers OF THE PAST heavily used it because there were no better alternatives

and they were trying to convince THEM that it was bad and to switch to stuff like loops, break, continue try catch etc.

but today these things are common knowledge, and profs are just pretty much parroting what their profs told them, and it is kind of useless cause your average programmer today hasn't even heard of goto

>>106168016
>how to tell someone youre a fizzbuzzer without actually saying it
every gui program has an event loop
that event loop can be a while (1)
it often is. its cleaner to call an exit function than breaking the loop.
but one could use a break or even a goto

if you have a program that doesnt need a window to be open at all times, you will have a while 1 loop for your program
and you will have a while 1 loop for your event loop
again, i would have used an exit function because i find it cleaner
but someone else might use a goto
and its not the only case where you could have a double inifnite loop

and infinite loops arent the only case where you might want to short out of a loop without further conditionals
if you want to go fast, you also might want to use a goto to short out of nested loops
and sometimes it just doesnt fucking make sense to fiddle around with the "usual" flow control statements
admittedly, i remember one such instance in my whole c programming "career", ~300 klocs
but such situations do exist.

>>106167245 (OP)
it's for retards without tail-call optimized recursion

>>106167973
That code is atrocious.
for(int i = 0; i < haystack.size(); i++) {
if (needle == haystack[i]) return true;
}
return false;

>>106168085
>same as goto then, why would you need to read the goto but not hte function if you want to read the code, it's the same fucking thing

a = "niggers tongue my anus";
a = uppercase(a);
a = censor(a);
a = add_punctuation(a);
print(a);
I can read this piece of code line after line because functions always return to the point where they were called from. I don't need to inspect the functions if I don't have doubts about their implementation.

a = "niggers tongue my anus";
goto uppercase;
print:
print(a);

I *have* to follow the goto to learn the sequence of instructions - I can't just skip over it because there's nothing in this piece of code saying when (if ever) it will return there

>>106167699
I don't see how that's better, you just dislike the word goto because you were told to and because the herd dislikes it.

>>106167245 (OP)
At best, it's an ad hoc implementation of other structured control flow constructs. At worst, it isn't.

>>106167245 (OP)
You made a "without sounding mad" post about it. People who are right don't have to do weak things like that.

>>106167699
Maybe I'm retarded but I'd like to see something like break(n) to break n nested loops

>>106168386
Sometimes the herd is right, anon.

>>106168271
>its cleaner to call an exit function than breaking the loop
>would have used an exit function because i find it cleaner
guess that makes you a fizzbuzzer too, then

>>106168465
>refactor code by removing or adding nested loop
>cause bug

>>106168465
show code where the number of nested loops is a variable
otherwise, you can just count the loops yourself, label the one you want to break on, and break on label

>>106168349
Nocoder moment. What if we want to do something with the needle?

>>106168531
call a lambda

>>106168531
Depends on what you want to do.

>>106168531
for(int i = 0; i < haystack.size(); i++) {
if (needle == haystack[i]) return i;
}
return -1;

>>106168624
I don't want to make it a function.

>>106168624
the state of Cniles

>>106167858
>return on investment: 25 years
what's wrong with this?

>>106168624
The -1 is arbitrary here.
https://en.cppreference.com/w/cpp/algorithm/find.html

>>106168624
this sucks

>>106167245 (OP)
When Dijkstra was badmouthing goto, structural programming was appearing.
Meaning: goto was not used to exit loops or structure function flow, goto was used to jump from inside a function, somewhere else, without cleaning the stack, or keeping it constant. You started with variables x and y that had 2 and 2 and suddenly you were somewhere else with no new stack frame and then you somehow returned, or maybe not even returned to the function, and x and y were now 256 each and who knows what happened to the registers.
Procedures structured stack usage, automating it: get what you want, do what you want, return what you want, get rid of the rest.

>>106167973
It's actually filtering retards

I apologize for the shit solution with returning an arbitrary -1 value. Here is the fixed version:
for(int i = 0; i < haystack.size(); i++) {
if (needle == haystack[i]) return i;
}
throw new NoSuchElementException("Needle not in haystack");

>>106168467
Not this time they aren't.

>>106168775
for(int i = 0; i < haystack.size(); i++) {
if (needle == haystack[i]) return std::make_optional<int>(i);
}
return std::nullopt;

>>106168647
you dont see whats wrong with this?
it means the value of the company is purely speculative

for example a construction company has an roi of around 3 months or youre doing something spectacularly wrong

>>106168775
>new
>allocating on the heap to throw an error
this is completely fucking retarded
who taught you to program?

>>106168891
it's not a regular company.

>>106168919
it is a regular company
and you are a fanboi cultist

>>106168913
>he learned about C's memory allocation once
>he is unable to envision systems where memory is reserved in advance for situations like these, resulting in cheap "allocations"
the people behind the JVM are way smarter than you lil bro

>>106168960
>he is unable to envision systems where memory is reserved in advance for situations like these, resulting in cheap "allocations"
its called an arena
and its still completely
wildly
unimanginably retarded

and its default, right?
fucking sepples should be named seppo
because it seems to be maintained by aboriginals
and not those who drink beer, those who sniff petrol

all you need is a constant and a function
god sepples is so fucking retarded

>>106168960
Accessing heap is not an issue, but throwing a runtime exception, simply because you can't find an item, is a bad idea.
Here's what I would do :
const auto it = std::find(haystack.begin(), haystack.end(), needle);

>>106169040
>its called an arena
no, arenas indicate all entries sharing a lifetime. they also do not allow for memory defragmentation via reference updates, although that is more of a GC thing.
>all you need is a constant
so the string that the user sees is not variadic in size when considering potential contained values?
you really wanna annotate every single error condition for each function, as well as its dependencies? sounds annoying as fuck to me lil bro, that's part of the reason why I stopped using Rust.

>>106169086
>no, arenas indicate all entries sharing a lifetime. they also do not allow for memory defragmentation via reference updates
and why would that be, exactly?
>so the string that the user sees is not variadic in size when considering potential contained values?
who said the function cannot be variadic?
the constant is needed as error message but you can intersperse it with other data
and that still doesnt involve heap allocations

>>106167245 (OP)
Nothing, it's unironically optimal code. That's why GCC and Clang both have optimizer passes (e.g. gcc -ftree-tail-merge) that transform jeet-tier "structured" control flow into the equivalent of goto.
/thread

>>106169153
how are you planning to return that data (on the stack within your current function) without the heap?

>>106169240
pardon the fuck?
you completely lost me
explain what you mean like if i was 5

>>106169269
no, I do not care anymore. it is a useless argument. I'm going back to writing Clojure, because all of this shitposting is a waste of fucking time. we are literally arguing over heap use when throwing a fucking error. it does not matter. whatever makes the most sense at a human level is the best decision. if you expect to find the needle in the haystack, and do not, then throw a damn error and move on with your fucking life.

>>106169290
>no, I do not care anymore.
i think youre talking out of your ass and this is a tactical retreat
>closure
explains why youre retarded

>>106169290
>whatever makes the most sense at a human level is the best decision.
>>106169306
cont
retarded indeed

if that was the case everything would be written in python
learning functional programming turns you into a retard

>>106169306
Clojure is a very good language, and I say that after writing quite a bit (around 100k LOC total) of C, Rust, Python, Go, JS, TS, and others.

>>106169240
Pass a pointer to a buffer on the current stack frame. It just werks.

>>106167245 (OP)
This is ultimately what a microprocessor does.

>>106169354
Lol.

>>106169331
no
its slow
its limited
and its users are buffoons
case in point:
>he thinks 100 klocs between 6+ languages is a lot

everything you said about c users is actually projection
bc functionalshit is programming but for maffbois, so its immediately retarded bc maths dont map to computer ops very well
and its slow compared to proper systems languages
so its jumping through hoops for a disadvantage in the end. how briliant. truly genius

>>106168624
O(n) moment

goto is based and useful and cuts down on boilerplate

the only downsides are when you're a complete fucking retard and use it to break encapsulation or something

>>106169354
But unironically.

>>106169382
why do you care so much about performance? seriously, what are you doing that demands it? you do understand that by using a virtual machine (and boxing my types) I gain the human ability to have a REPL? I can SSH into a prod server, connect to a Clojure REPL, and start running diagnostics. I can run SQL queries using my existing functions that do so (and don't fucking tell me you are using stored procedures in raw SQL, those compose horribly and lead to non-DRY shit). the JVM's profiling capabilities are world class purely because it is a VM with the ability to introspect it.
with immutable data structures I gain access to absolutely fucking trivial concurrent behaviors. do you understand that with Clojure's immutable data structures and transactions system, I literally never have to even think about things like mutexes? have you even heard of software transactional memory? I eliminate entire classes of bugs by simply having my shit be immutable.
and, if performance actually does matter, you surely have enough experience to recognize that it only ever applies to some small subset of your codebase, right? I can write Java-in-Clojure (using any Java data structures I want, or libs, such as Roaring Bitmap, or the Disruptor) without any issues. it's trivial. it's less LOC and cleaner (imo) than fucking Java. there is nothing stopping you. you can use type hints. you can match Java speed in Clojure, and this has been demonstratably done in numerous Clojure codebases.
if Java is not fast enough? I literally do not give a fuck at that point. someone else can port my shit to Rust (which will be trivial btw, ports are never that difficult, the difficulty is always in the business logic). I do not have enough time on this planet to give a shit about reaping Rust/C speeds out of my codebases. I am here to solve interesting problems, and optimization is not one of them.

>>106169497
AI bros are sucking up all the water with their inefficient software. It's joever.

>>106169354
>>106169472
wait, youre implying the other retard wrote what he meant?
fukken lamao
such is the power of clojure and 100klocs bw 6+ languages...

>>106169290
ey, retard
you just create a buffer in the context that contains your function and you pass a pointer like youre supposed to have learned in cs 101

>>106169497
>why do you care so much about performance?
because for me its the difference in waiting for my computations one day vs one month
>what are you doing that demands it?
ML
>inb4
i actually use openclC to do the heaviest of lifting. runs on the gpu, obviously
i use C for the rest because its a tool that fits my hand
i have very powerful visualization abilities, talents in many fields and i am a strict person
so the low level of c, the lack of standardized interfaces, and the lack of memory safety are not a problem for me
theyre features i desire. anything more would just create friction in the process

heres an example of my code
i dont even have use for templates or generics because i use force inlines to turn my code into legos
>but its not portable/idiomatic
i dont write idiomatic C and i think its a retarded idea to begin with

>>106167354
No, you can only goto within the function.

>>106169354
btw, allocating before the error even occurs results in poor performance
the correct thing to do in Cnile-lang is pass a null pointer to allocating to if needed.

>>106169538
No, I didn't even read the parent.
>such is the power of clojure and 100klocs bw 6+ languages...
Your insecurity is showing.

>>106169665
don t try to save face
youre only digging deeper

you dont even know you can pass references to a function
such is the power of clojure and 100klocs bw 6+ languages i guess

>>106169630
>results in poor performance
Source?

>>106167245 (OP)
there's nothing logically wrong with this, but it's very unreadable and shitty for humans, specially with you're working in a huge project with a lot of devs, in that case good luck understanding what the fuck is going on

>>106169683
>no arguments made
I accept your concession.

>>106169683
post code lil bro
this is a hash map implementation I wrote in Rust that outperforms Swiss Table in some scenarios

>>106169715
alrdy posted
>hash map
geeeeeg
now i understand why crabs youre raving about hashmaps
its all you can do

post bucketsort
its gonna be a week im waiting for that

>>106169710
none needed
ur a retard
you dont even know you can pass references to a function
any argument would fly right past you

>>106169715
Now show us the benchmark code, where you feed it the same string a million times and get perfect branch prediction.

>>106169726

>>106167245 (OP)
Nothing is wrong with goto. Nothing at all. Somebody once wrote a paper that included it in the title, and for decades, people have argued about nothing because they never read the paper and just took the title completely out of context.

>>106169757
>crab reinventing the wheel
but i thought you used rust to avoid exactly that...

so even rusts libs are shit
why do you even bother with this failed abortion of a language then?

>>106167245 (OP)
It looks nice and clean in this simple 1-ary example but start to spam it multiple times and you end up with spaghetti eldritch abominations. Although some kind of tracer or dependency graph utility would mitigate that.

>>106169725
Cope.

>>106169331
It's shit. Good code flows straight down the page, and doesn't jut out like this.

>>106169782
cope?
that YOU are a shit programmer?
i think you misunderstand the term...
heres a definition

>>106168052
you test it the same as any other function
you can't goto out of the function
it's not long jump

>>106169765
you could have written a paper decades ago titled "C considered harmful" and today you could write "C++ considered harmful". The fact that anyone as stupid as OP would be talking about goto is laughable.

>>106169839
If it's to get out of a loop there's the break and continue statements that can be used instead.

>>106169946
yeah but getting out of nested loops can be a mess
and is more expensive than a goto
you will have one additional conditional per nesting level you will be exiting

>one additional conditional
*at least one additional conditional
or at least a case statement
multiple jumps in any case

>>106169991
>getting out of nested loops can be a mess
Java solved this with labeled loops

>>106169991
I think it's an acceptable use of goto in that case. Specifically nested loops short enough not to be broken down into function calls.

>>106170043
goto is easier to read than labeled nested loops because the label is at the jump destination instead of before the start of the loop.

>>106170043
and c solved it with gotos ¯\_(ツ)_/¯

fuck goto i longjmp

>>106170053
theres also error handling
gotos instead of copying the same constructs all over the place
it makes stuff more readable and avoids duplicate code >>106167359

>>106170074
dangerously based

>ummmm let me goto my error handling logic rather than implementing the Drop trait for my type

>>106170105
yeah
why would you need some retard-proofed constructs when a goto will do?
oh right
youre a crab, i tend to forget

>>106170059
goto can fly anywhere in a function, not just to a loop. it's not equivalent

>>106170056
outer: for (int r = 0; r < rows; r++) {
for(int c = 0; c < cols; c++) {
if (table[r][c] != 0) {
nonzero++;
continue outer;
}
}
}
what's difficult to read here?

>>106170079
that code looks awful
not because of any piece of the logic, but because C just looks awful

>>106170190
>goto can fly anywhere in a function, not just to a loop. it's not equivalent
yeah
goto is better
it makes for a simpler language

>not because of any piece of the logic, but because C just looks awful
its bootyful
its just that you have bad taste

>>106170190
I've never seen this before. I would not mind this in C at all desu.
I usually either use a flag, or if my iterator variable is local to the loop I make it break the condition.
But a named loop is sexy

>>106167315
No it fucking doesn't.

>>106168348
it's telling that nobody has even commented on this

>>106170316
duh. talking to fptranies is a waste of everybody's time

>>106170336
>he thinks he is always correct

>>106169785
eh, you get used to it, and it adds "texture" to your codebases
Lisp has one of the most braindead-simple indentation/alignment methodologies of any language, once you learn it

>>106170190
>because C just looks awful
OK, and? You're not one of those eLeGanT cOdE retards, are you?

>>106170345
projection as evidenced itt
hopefully at least you know what a reference is, kek

>>106170367
I've never used LISP, but have been reading about rule-based expert systems. Which, of the like 1 that exists, is written in LISP. Can confirm, LISP is dogshit simple to read

>>106170380
c looks beautiful if youre into industrial aesthetics

>>106170382
>ummm I hope you know what a pointer is :^)
>I'm, like, pointin' around

>>106170400
>basedquote
and then you act surprized people think you have fuck all to say
you suck even at shitposting

>>106170105
>Hidden logic is good bro! Every other lang that did that didn't turn into mandatory LSP slop.

>>106170390

>>106170408
99% of functional programmers have done imperative shit
maybe 5% of imperative programmers have done functional (and immutable) shit
which side do you think knows more? why don't ya, POINT to the side you guess?
lmao, get it?
point?

goto is harmful inasmuch as C itself is harmful

>defer technical spec coming in C2Y
>mogs your favorite language

>>106170439
>99% of functional programmers have done imperative shit
then they havent done enough of it because as a rule theyre retarded
3 separate fptranies ITT didnt know about references

>>106170439
>which side do you think knows more?
Imperative programmers.

>>106170440
Source for either of those claims?

>>106170505
why would you need a source
hes right
gotos are as harmful as c.
which is as harmful as a hammer. or a kitchen knife. or a screwdriver

>>106170383
what do you think of them so far? I've been meaning to learn Prolog or similar. I find the concepts similar to databases (as far as I am aware), which I find incredibly powerful, mainly due to their autonomous use of indexes, which are a grouping of data structures without the need to keep them in sync manually.
there have been some problems where I have given consideration to using an in-memory database purely due to this fact (as well as the trivial ability to write complex queries)

>>106167245 (OP)
compiler won't let me jump over allocations

>>106170530
>cue 3-4 more samefags
>until you realize nobody gives a shit about you
>and then right back to shitflinging
such is the MO of the fptrany

>>106167716
i don't like the for loop syntax

>>106169804
>still coping
Kek.

>>106170523
>no source provided
I accept your concession.

>forget to have statement that makes it return to the top
>it skips all the code in between

>>106167716
You see backward jumps working around hardware errata. For example, let's say, statistically, some hardware tx function wedges itself once every 100 days under 100% utilization because some chink XAUI block tied together by chinks shits itself, and you're 21 layers deep in call stack. You'll just want to detect it, reset the block, delay a bit, then jump back up to where you were before and fall through again. You'd do this rather than changing shit around "the right way" because some chemical plant loses $1M per minute of downtime and changing the other shit may cause timing differences, different compiler paths, etc, etc, plus more time for QA approval. When you have to do this, it's the least bad thing to do.

>>106170651
>coping is when i get called out
err no
i even posted a handy picrel for you
>>106169804

>>106167245 (OP)
this particular problem is best left to the compiler. its not that humans cant, its just that its boring and easy to fuck up.
c does it right that it limits you to function scope. don't ever go full longjmp()

>>106170690
>don't ever go full longjmp()
>mfw

>>106167245 (OP)
It's bad for the same reason that raw ASM is bad. Structured programming concepts (e.g. loops, if statements, etc) better conveys the intention of a goto statement in a more clear way. Considering that, when you do see goto (like goto exit in a c function) it's pretty clear what the intention is.

>>106170688
this is me reading your absolute insanity

>>106170716
>code monkey
about on par with what i expected

>>106170720

>>106170753
you quite literally did this to yourself though

>>106170456
BASED hasklel

>>106170530
I had taken a course on "AI", not GPT, where we really only spent a couple weeks with expert systems.
I've been on & off reading the book "Rule-Based Expert Systems" (Buchanan, Shortliffe, et. al).

Databases are more suited towards large amounts of generic information that is processed 1 by 1. Or commonly referenced records.
In an Expert System you're dealing with just 3 sets of information. In this case its a large LISP program, so everything is in LISP syntax, including factors, rules, goals, everything.
The program doesn't quite work on large amounts of data at once, but bite-size pieces of information, like "bob is a man", "bob is over 30", "the culture was received from a sterile site", "the sample site was blood", "blood is normally sterile". These are all given certainty factors (not conditional) to provide confidence to the assertions.

I think the relationship with databases would basically start and end with conditional logic. After that, the use-cases are just too far apart. an expert system is focusing on processing rules, while when you use a database you're looking to process the data itself. I think you would rarely find yourself doing any time of set operation on a table, in an expert program.

I've never actually looked at PROLOG before, once I finish my non-data science project I might check it or LISP out. Ever since I took that course on AI I have been kinda just looking for an excuse to build an expert system. But I don't have day-to-day problems that require expert level knowledge.

>>106170771

>>106170778
why the animal abuse?
everyone seems to hate the poor gophers
idk the language but they seem to be pretty chill people...

>goto line x
>code is added above the goto code later

>>106170791
basic?
10 PRINT "Enter a number (0 to exit):"
20 INPUT N
30 IF N = 0 THEN GOTO 70
40 PRINT "You entered: "; N
50 GOTO 10
70 PRINT "Goodbye!"
80 END

>>106170790
>everyone seems to hate the poor gophers
The key point here is our programmers are Googlers, they’re not researchers. They’re typically, fairly young, fresh out of school, probably learned Java, maybe learned C or C++, probably learned Python. They’re not capable of understanding a brilliant language but we want to use them to build good software.

>>106170788
>more self harm
anooon
you dont need to do this
just write in c, its gonna cure all your problems
it cured my erectile deficiency AND my male pattern baldness

>>106170827
you mean
>bully them into writing good code?
hmmmm. this opens many possibilities...

>>106167245 (OP)
Nothing is wrong with it. Embrace the goto.

>>106170824
Right I was mistaken

>>106170875
'happens to the best and god witness were not amongst them

>>106170865
based fortranchad

>>106170783
>expert systems
oh fuck is it the 80s again?

>>106167245 (OP)
Deprecated by throw.

>>106171248
fuck your throw. try catch these nutz, faggot

>>106171248
i see your investment with dr mr durgasoft has paid off

>>106171220
I want to believe they have some use.... Like running an expert system in EU4 or some other overly convoluted game. I think if I did end up learning prolog to make one (whic btw, check this semi-broken webpage out https://cinuresearch.tripod.com/ai/www-cee-hw-ac-uk/_alison/ai3notes/all.html) I'd start out with something like resource management and production planning in space engineers/factorio...

>>106168069
Linearity is the reason why every programming language sucks at concurrency, by the way.

goto breaks the natural flow of the structured code. Sussman and Guy Steele fixed that with the lambda expression.

>>106167354
>Isn't this just like a JMP instruction?
Very similar concept.
Most high level language users have no idea how computers or CPUs actually work.
The code gen people of your favorite language definitely know how they work.
It's just a cargo cult opinion that goto's are bad, because nobody perpetrating the myth has used/seen/experienced a large-scale BASIC program that abused them.
In 2025, we tend to use GOSUB more since there's less overhead than we had in the 80s.

>>106171530
> Sussman and Steele invoked
Plase be informed that even the lisp machine’s bytecode implements unconditional branch instructions.

>>106172094
no one care about the implementation, this is irrelevant.

>>106168119
I washed my penis.

>>106168069
So functions should not have loops or other control flow constructs either. Exceptions shouldn't exist. Function calls shouldn't exist either, especially recursion. You are a retard.

goto is kind of amateur.
computed goto is where it's at. Subhuman trash never got to the first instruction set.

Why are you all getting so angry? Why can't we just delete science and shitwash over it like the subhumans we are? No more goto. Only clearly *clap* defined *clap* functions.

Is everyone here a jobless neet or something?
You'll never see goto at production code and for good reason

>>106168386
>I don't see how that's better
you don't need to keep track of a label outside the loop just to exit it, especially if you modify something down the line

>>106167245 (OP)
Nothing. The goto that the original paper complained about was the completely unrestricted one that could jump forward, backward, into completely different parts of the program.
Not the gimped goto that's in modern programming languages. And even then, he advocated for more modern structures like if with blocks, for loops etc where it makes sense, not for a complete ban of goto. Just use the more "restricted" constructs where they work and reach for goto as a last resort.

Of course the modern programmer doesn't understand that. They read the title, they think
>goto? Programming languages have a goto keyword, so it must be that one!
and then cry and piss themselves in fear that the evil goto boogeyman will explode their program if they use the goto keyword even once, even where it makes sense.

>>106167699
you can just break out of an if statement in java directly
bye:
if (condition) {
break bye;
}


a label can be slapped on any statement, you can even slap it on the break statement itself
wtf:
break wtf;


try it https://learn.java/playground

There is ABSOLUTELY NOTHING WRONG with computed jumps UP the function call stack.

>>106167245 (OP)
goto loops ignore scope and can roll into eachother unlike real loops which has a defined body
this is the main problem with it

>>106172576
just to add, this is called structured programming. the naming is coming back with structured concurrency

wait until you see structured metaprogramming

>>106172624
metaprogramming is just programming, which is already structured, sadly. structure gang won

I've never heard anyone say it's bad, I've only heard people say it should only be used when it's more succinct to do so. Like specifically with error handling and cleaning up memory.

>>106167359
I've never used goto (outside asm) and I've programmed in C11 for years. What even happens to all the variable declarations/expressions you skip with it, you just have to know to never reference them after goto?

>>106172576
>goto loops ignore scope
Oh.
I know that.
When I want to ignore scope and jump to a random address, I will do so.
The computer does what I want. I will not abide by arbitrary limitations based on some uninformed fanciful opinion that someone had.

>>106172715
you're welcome to write spaghetti code

>>106167394
>goto makes code hard to read. that's it. the actual problem.
I agree functions also make code hard to read, why have them for anything but external calls.

>>106172698
>variable declarations
local variable are allocated on the stack all at once in the function prelude
>expressions
same thing that the else branch of a conditional when the condition is true, it's not executed

>>106169630
Not if you don't allocate on the heap dummy.

>>106173037
Yeah sure, so their memory contents are just uninitialized then.

>>106173017
>functions also make code hard to read
substantiate your claim

>>106173108
if you jump over the assignment then yes. allocating stack space and assignments are distinct operations

>>106173166
Interesting of you to clarify that, as if it wasn't obvious from the discussion, but whatever I guess.

>>106173180
The answer to your initial question was very obvious in the first place. Obvious is what you were asking for.

>>106167245 (OP)
It is difficult to debug

>>106173192
One could say it should've been obvious, but I don't like assuming things blindly. I've never had to know this detail so I asked about it and you delivered, so thanks for that.

>>106171638
>Why ain't people just code in binary since everything gets compiled down to binary code anyways
Try a bit and you might realize why programming languages were established in the first place.

>>106167245 (OP)
we have production code with thousands of macros that uses gotos under the hood.
Makes the code only readable because the macros are used, otherwise for anything over 300 lines it becomes a mess.

>>106167315
>it doesn't matter what the scope is
you can't go out of scope with modern gotos retard.
the jump instruction and the label needs to be in the same function, or it won't even compile.

>>106167245 (OP)
it should only be used to kill code repetition, for example if you need to do a job inside a loop that accounts to 600 lines of code and then you need to do the same job outside the loop, you would not just copy paste the 600 lines, thats playing with fire, as there is no gurantee your monkey brain wont do slight barely visible changes to one part of it

>>106167245 (OP)
Gotos are only really useful in languages which allow indirect reference. If you aren't using indirection to determine your labels, there isn't much of a reason to use them.

>>106167378
This. If you need goto you should probably be writing assembly anyways. Goto is an assembly idea (jump instruction) ported to C for low-level programming. But if you go this low-level then you might as well write straight assembly.

>>106167267
based

>>106167326
>It makes the code harder to read
Not really, depends but sometimes a goto is the simplest and clearest solution. Like when you're deep in nested shit and you have to get out of the whole thing.

>>106167359
goto error; is a perfectly fine way of doing things. I'll tell you what really makes your code spaghetti:
>just put parts of your function into their own function that won't be reused because that's Clean Code™ that won't need commenting so when you read the parent function you have to jump to all the subfunctions to see what they do
>no you can't just write numbers bro you have to use macros and enums so whenever you want to know what's going on you have to jump to their definition in another file

>>106167315
>shift control
I don't speak tranny so idk what that means. Goto go jmp, you need jmp.

>>106167636
based

>>106167656
>Oh noo my flow is all broken
wtf does that even mean lmao, an if or loop might do the same thing to your flow, but might look worse. It's all in your head.

>>106167716
Sometimes I use goto to loop. I can't think of any problem with that, it's no worse than a normal loop, it's straightforward, it's natural, it just werks.

start:
<do a bunch of stuff>
if (condition) goto start;

>b-but you could use a do-while loop
Why? To add another level of indentation and do exactly the same thing? There's another advantage, I can do this:

start:
<do a bunch of stuff>
if (condition) goto start;
<do a bunch of stuff>
if (condition) goto start;
<do a bunch of stuff>
if (condition) goto start;

>>106168069
>the linearity of reading line after line is still ruined
same thing with any other loop lmao

>>106168119
>but 99% of the times there are cleaner alternatives
No, also if there are I don't care. When I write something I don't consider all the alternatives that retards who get their ideas from books might like, if it werks it werks, if it's good enough it's good enough.

>>106167699
More languages should be like perl.
outer:
while (1) {
while (1) {
if (condition) {
last outer;
}
}
}

>>106167693
>if you know you know
>first reply clearly doesn't know

>>106168349
>>106168624
No one said anything about a return.

>>106168041
This, everybody jumps
>b-but I read in a book written by some retard that this way of jumping is le spaghetti!!

>>106168380
Contrived example that uses goto like function calls. Just because you can think of a bad example doesn't mean there are no good examples. The best uses of goto aren't for doing the equivalent of calling a function, it's for skipping some stuff, getting out of some stuff or looping.

>>106168465
Why not just goto at this point?

>>106169206
Yep, it's all jumps, anything that obscures that is just an illusion.

>>106169702
>it's very unreadable
no it isn't

>>106169785
This is the most ridiculous thing to complain about

>>106170105
>Drop trait for my type
These words mean literally nothing to me. I'll blame trannies for making up these words.

>>106170569
based

>>106170791
>>goto line x
We're talking about gotoing to labels

>>106172681
Dangerously moderate opinion, we can't have that here. Either gotos are dangerously based or goto writers are madmen/unemployed nocoders.

>>106173134
You have to jump to them to see what they do. It's much better to have a paragraph of code in your function with a comment right about it that says what the paragraph does. Functions are just when you need some code more than once, then they're a necessary evil.

>>106173199
It isn't.

>>106173771
This is true, but the board is full of zoomers who have never heard of indirection, so they're just arguing about readability and if you should listen to people who say it is a bad practice or not.

>>106167716
>Jumping back though? That we don't do.
if (cond_unlikely1) {
goto unlikely1;
}
ok1:
if (cond_unlikely2) {
goto unlikely2;
}
ok2:
if (cond_unlikely3) {
goto unlikely3;
}
ok3:
// work
return val;

unlikely1:
// realloc
goto ok1;
unlikely2:
// realloc
goto ok3;
unlikely3:
// realloc
goto ok3;

>>106174010
>>106174019
>Contrived example that uses goto like function calls
read the context of the post

>You have to jump to them to see what they do.
you missed the point where I can also not jump into them and instead can skip over and continue reading line by line
which you can't do with goto because it doesn't return
>It's much better to have a paragraph of code in your function with a comment right about it that says what the paragraph does
it's not
in most cases, a well-named function replaces the need for a comment
also comments should state the 'why', not the 'what' - the 'what' is the code itself, no point in duplicating information
>Functions are just when you need some code more than once
functions also allow for tighter scoping of variables - each section of code will usually not need every variable to be in scope, so separate functions can use fewer and only the relevant parameters
another point is that all IDEs and many text editors offer an outline view of a source file - a list of all functions. this works like a table of contents in a book, enabling easier and faster navigation over the source file.
yet another point is that functions are easier to share or work on separately when working on a shared codebase by a team

>>106174156
it doesnt make sense, just put your shit in the corresponding if block

>>106172136
>So functions should not have loops or other control flow constructs either
loops, ifs, switches, etc. you can skip over them and continue reading what's after
you can't skip over a goto because nothing at that point says if/when the code after it will be executed
>Exceptions
as the name implies, they're for exceptional situations
and the main thing they do better than goto for exceptional purposes: they do not mix into the regular logic, instead they have a separate and distinct throw/try-catch mechanism
>Function calls shouldn't exist either
ad absurdum
>You are a retard.
ad hominem

>>106174263
that way there are no jumps in the fast path and the you can improve code density, good for the code cache

>>106174397
thats smart.
not taken

>>106168467
theres literally hardware instruction for goto, JMP
you're dumb normie kys

>>106174397
>>106174428

*notE taken

>>106174397
why don't you autists try doing something productive like writing compilers that do all of this shit for you? you would learn far, far more.

>>106174638
>something productive
>like writing compilers

>>106174674
it's way more fucking productive than trying to optimize your cache use by using goto for some code that probably only you run on datasets that are less than a gb (I'm being very generous here)

It's too powerful a tool for mortals. Imagine if you, a human, had the ability to teleport. Before long you'd kill yourself teleporting somewhere stupid. GOTO is unconstrained code teleportation.

GOTO would be cool if it maintained variable scope. Like, you maitain the state for each scope you jump out of and can return to it later. You could explicitly take variables with you too.

>>106174696
>yeah just write several milions lines of code instead of using your brain for 5 minutes and drop a well placed goto
not to mention your hand optimization > compiler's

what is it with retards and the need to inject their retard non-opinions into every discussion they take part in?
is it because of reddit?

>>106174804
>he doesn't know of the concept of adding his work to an existing compiler, or working with a fork
oh look, a learning opportunity.

>>106167245 (OP)
It's perfectly acceptable.

>>106174842
>implying the compiler has cognizance of the data you will be working with

ill let your brains warm up before explaining

you set?
lets go
lets say you have a set of numbers you have to sort
lets say you know the only disorder in the list will be a couple numbers that have to be permutated

a naive permutation sort will be the fastest algorythm for the job
but would be the one of the slowest performing ones on any other dataset
choosing he right algo for the data is the first step in optimization
and is perhaps one of, if not the most powerful optimization technique.

and a compiler is completely incapable of it, and never will be, because a compiler doesnt have cognizance of the data it will be working with
now go back to your studies, you have yet alot to learn

>>106174784
this has similarities with how Prolog is compiled

>>106174886
>implying the annotation of information for compilers is an unthinkable concept
surely you know of type annotations, Python decorators, etc.?
I highly suggest taking your brain and its optimizations capabilities, evaulating what information you process when driving them, and identifying manners of representing these sets of information in a manner visible and useful to a computer.

>>106174638
of course, this kind of stuff is meant for people generating assembly/machine code

>>106174911
for example, what could a compiler do with a new branching construct, called `unlikely_if`?

>>106174696
writing compilers is the ultimate busywork and pseudointelligent wankery

writing something productive means writing software with actual features and for actual users
if you write code that is not meant to be used by anyone - it's not productive

>>106174784
anon, you have invented functions

>>106174911
>implying the annotation of information for compilers is an unthinkable concept
this is dumb, bc it doesnt cut the crap, it cannot cut the crap given the complexity of the problem and why do things in a roundabout way to begin with?
also compilers are not code generators, theyre code translators
it still up to the programmer to express the algorythm thats expected to be compiled

>I highly suggest taking your brain and its optimizations capabilities, evaulating what information you process when driving them, and identifying manners of representing these sets of information in a manner visible and useful to a computer.
so that retards can do the same?
no. fuck em.
if i wont benefit from opensourcing something then i wont opensource it.
if i wont benefit from creating procedures, then i wont create them.

i have no qualm with using opensource myself because if people wanna work for free thats their choice
but its not something i will do myself

>>106175027
so you're retarded
I thought we were getting somewhere
oh well, I like the idea of `unlikely_if`, and similar concepts. I will add it to the todo list, and maybe get around to it one day after I finish my other 20 projects on the backlog.

>>106175048
>doesnt know shit about optimization
>doesnt understand shit about the discourse
when are you going back?

>>106172576
>>106172606
Lowest IQ poster ITT. I fear for your offspring, should you have any.

>>106172790
t. "JavaScript Engineer"

>>106167716
>Jumping back though? That we don't do.
Who's "we". I do that and code circles around you.

>>106174952
not him but modify the order of the basic blocks, or emitting branch prediction hints before conditional branches for architectures that have it. x86 has it but it may have been deprecated now and may do nothing, not sure

It can also be used to determine how to best compile the body of a loop (that has been unrolled or for SPMD or GPUs) when there are branches inside, wether use normal branches or do an if-conversion which allows you to remove conditional branches but at the cost of always executing all paths. This will only lead to faster code if the branches have a similar number of instructions and if there isn't an unlikely branch. basically

>>106175229
forgot to say that the if-conversion thing and removing the conditional branches is to be able to vectorize a piece of code that has conditionals

>>106174988
No, functions have a single entry point. I want functions with an offset.

>>106175229
>>106175246
Least obvious larping compiler engineer.

>>106174952
look at the linux kernel. they have a likely/unlikely macro over a gcc builtin

>>106175229
>emitting branch prediction hints before conditional branches for architectures that have it
That's not how branch prediction works in 2025, you dumb fuck. Stop larping.

>>106167636
>>106167699
>break 2;
Now what?

>>106167708
Easier said then done when you're on a project with 100+ programmers, fag

>>106175763
there should never be a singular project with more than 5 devs, and even that is pushing it (I prefer 3 for tolerance of negative effects such as unexpected dev death).
break out your project into smaller projects. programming languages have great support for this concept, called "libraries."

>>106175763
>100+ programmers
>on a single project

>>106175809
>monkeys and typewriters

>>106175381
problem?
>>106175406
finish reading the sentence

>>106167245 (OP)
>Explain what's wrong with it
The instruction says "go to label" but the program actually goes below the label. Wtf

>>106167267
fpbp

>>106175763
>a project with 100+ programmers
What the fuck? Where do you work at?

>>106179443
that github repository that the pajeet youtube tutorial linked to and 100+ shitskins make pull requests for changing a sentence in the readme or some comment

>>106167267
>clean your code, bucko.

>>106173844
>just put parts of your function into their own function that won't be reused because that's Clean Code™ that won't need commenting so when you read the parent function you have to jump to all the subfunctions to see what they do
This makes the overall structure of the function more readable. And your function names should say what they do.
>no you can't just write numbers bro you have to use macros and enums so whenever you want to know what's going on you have to jump to their definition in another file
Likewise using enums or named constants means that instead of say "12" you have "MONTHS_IN_YEAR" and you know WHY the variable has the value that it does. And you don't have to jump to another file you just hover over it and your IDE tells you its value, unless you're some vim/emacs/whatever retard in which case you're doing it to yourself.

>>106168465
Labelling the loops is easier to get right and keep right than counting loop levels. Let the compiler do the counting for you.

>>106167245 (OP)
goto is a primitive construct; it can be used for many things, so it is more mental effort to see how it is being used this time
use it when you have no other option that expresses your intent better

the compiler is never confused by it; if you want that, you need longjmp(), and may god have mercy on your soul

>>106173037
>local variable are allocated on the stack all at once in the function prelude
lolnope, except for no-optimization builds
when the optimizer is on, a variable may never be on the stack at all, or may be on the stack multiple times; modern compilers have many options for chewing stuff around, and you should learn about static single assignment form before commenting further
and the compiler may also just choose to adjust the size of the stack frame at any time it wants; that's not required to be constant through the life of the function call

Nothing that isn't opinionated. This is one practical use for it:
#include <stdlib.h>

// example size
#define SIZE_LENGTH 20

#define ERROR_UNKNOWN -1
#define ERROR_SUCCESS 0
#define ERROR_OUTOFMEMORY 1
#define ERROR_INCOMPATIBLE 2
#define ERROR_ERRORSECOND 3
// etc... Could also be enum

int example(void){
int success_code;
int* example_alloc; // Could be any type, but int* is used for example

success_code = ERROR_UNKNOWN;
example_alloc = (int*)malloc(SIZE_LENGTH);
if (!example_alloc){
success_code = ERROR_OUTOFMEMORY;
goto fin;
}

// Do operations. For instance:

if (example_alloc[14]!=88){
success_code = ERROR_INCOMPATIBLE;
goto fin;
}

success_code = ERROR_SUCCESS;
fin:
free(example_alloc);
return success_code;
}

>>106167245 (OP)
hard for juniors and ChatGPT to understand

>>106167315
uhhh maybe don't hardcode asm(LJMP xyz) into your constructors then? goto is not setjmp or ASM, the compiler doesn't disintegrate if you use a single goto.

Two facts:
If you give an idiot access to jumps any function over 10 lines becomes unreadable.
Most programmers are clinically retarded.
The damage jumps can do to a codebase is far greater than the benefit of the two times using jumps is marginally better.

>>106182832
>If you give an idiot access to jumps any function over 10 lines becomes unreadable.
>Most programmers are clinically retarded.
not my problem

>>106182359
I know all that, this doesn't change that generally if there aren't enough registers to store all the maximum number of variables and temporaries live at a single time, the stack space needed to store the spills will be allocated in one go in the function prelude.
>you should learn about static single assignment
already do, what about it?

>>106169715
update: the bottom keys seen in >>106169757 previously fucked my shit up bad, resulting in ~2s, but I made a small change and now beat Swiss Table in all of my benches so far. more testing is needed.