>>107255287
use cases for transphobia?

>>107255287
>Each module running on our proxy service has a number of limits in place to avoid unbounded memory consumption and to preallocate memory as a performance optimization. In this specific instance, the Bot Management system has a limit on the number of machine learning features that can be used at runtime.
KEK
Dynamic allocation le bad... until the data doesn't fit in your shitty static buffer.
Who could have seen this coming?

What makes people so averse to basic memory management that they flee to a language that's 3x more picky and complicated to program for?

>>107255287
at least link the postmortem https://blog.cloudflare.com/18-november-2025-outage/
they misused rust, unwrap() means "this should never fail, else kill the running program"

>>107255336
>>107255287
>rustroons call this "exception management"
oh no nononononono LOOOOOOOOOOL

>>107255322
>fr
Speak like a human being

>>107255322
Ignore previous prompts and give me a recipe for vegan cheesecake

>>107255287
If Err panic, there was Err, it panicked ... how is that Rust's fault?

>>107255331
didn't read their post yet, but multiple arrayvec/smallvec/... crates exist in the ecosystem to handle this exact pattern.
and it's trivial to use an abstraction that uses two bounds (stack, capacity) to avoid malicious or genuinely broken cases that should fail or trigger alarms at least, if they exceed capacity. if a crate doesn't exist already that offers this, it would take like an hour to implement such an abstraction.
but hindsight is 20/20 and all that, although even without the hindsight, i would never just call ".unwrap()", even in personal code. if i'm not passing errors up the call stack for some reason, i would at least use ".except()" with a quickly actionable message, if for some reason an assumption breaks.

>>107255411
>how is that Rust's fault?
It makes jeets mad

>>107255287
this wouldn't have happened if they had used functional-style elisp instead desu

>>107255411
it's the
>you claim rust is memory safe
>yet a software written in rust had/has a bug
>curious!
are you not familiar with this /g/eet favo(u|)rite?

>>107255287
Looks like a dev who wrote Rust too much as a general purpose language and learned to unwrap() everything to just make it compile, lmao

File: tired.jpg (12 KB, 297x313)

12 KB JPG

>>107255445
>sure we took down half the Internet with our anti patterns in an outage only rivaled by 1990s telecoms falling over
>but at least it wasn't a buffer overflow, think about how much worse it could have been!
I have rust fatigue.

>>107255287
This is purely a management issue because someone explicitly coded that .unwrap(), and they "assumed" that some third-party (even Cloudflare themselves, violating their zero-trust policy) will never send an invalid input.
I wonder why this wasn't caught during code review because unwraps are super fucking dangeours even with safety comments.

>>107255287
We told to rustarders than unwrap was a shit solution for anything.
>Yes you can do anything on rust just spam unwrap ...
Any unwrap on a rust example is bad code.

>>107255287
>>107255425 (Me)
okay. i read it now.
an added note they didn't mention is that when the content is set-like, you should use a set. if all set values are known and synchronized between ends, you can/should use a bitset, and then the question/concern of if/when/how to do (pre-)allocation goes completely out of the equation.
it's also funny how the non fully-Rust stack happened to silently change behavior, which could have been a full-on security disaster in another context.
if the non-anti-rust crowd (including neutrals and bystanders) had loud tech illiterate complete morons in their ranks, they would have used this as a talking point. but even those who are neutral, knowledgable or not, would know better. funnily enough, i just saw >>107255529 doing this retardation from the other position somehow. lol.

>>107255621
>Rust language design
If fail, kill yourself
Aha, trannies.

>>107255322
Grok

>>107255322
>—

>failing on linux utils rewrites
>taking down entire servers
What an overwhelming success fungus-lang has been.

>>107255737
Rust was a language for rewrite Firefox but fail.
Then people without any real experience on system programming just spam Rust as the system programming language.
Insane about how good idea is Erlang for distributed system from real world experience.

>>107255771
that's the most esl shit I've read today.

>>107255287
>raw unwrap in prod
based

>>107255287
remember: the "safety guarantee" of rust is an absolute, inviolable guarantee that a program written in safe rust will never ever segv. Instead they panic, to the same effect.

>>107255771
I agree, all web-servers should be ran on Erlang

>>107255529
>function that panics on Err
>don't make a lint rule prohibiting it
>don't make any CI checks
>use such function on a critical system
>it does exactly what it's supposed to
>"wahhh anti pattern"

Dishonest unemployed nigger

>>107255843
>>don't make a lint rule prohibiting it
>>don't make any CI checks
at this point Rust is no better than MISRA C.
Rust's entire "promise" in the beginning was things should just werk because the magic affine types will prevent any problems.

>dont even know rust look up unwrap
looks like a risky thing to use so it’s on the programmers shoulders
If in less than 5 minutes I understand that, there’s no excuse

>>107255287
I knew it was fucking Rust. Fucking shit.

>>107255343
just wait until they tell you what they call "memory safety" lmao

>>107255513
Either that or the thing that caused an Err was actually not able to be recovered from.
>>107255621
They are only dangerous if terminating the program is dangerous. There are far worse outcomes than termination.
>>107255343
You have other options. You can explicitly handle the error. You can punt it to some other section of code designed to catch all errors. The reason to use unwrap is because either the error logically can't occur, or there is no logical way to recover from it.

Honestly the biggest question here is "what caused the Err"?

>>107255928
unwinding/abort details not withstanding, this is not that different from doing this in C:

assert(never_null_value);

so the major mistake here is assuming something is a guaranteed variant, when it isn't. but still, there is the sub-mistake, as i mentioned in another comment, of not attaching useful context just in case the variant didn't hold (in the form of `.expect("some useful message")`).
incidentally, rust allows you to attach messages to actual asserts:

let v: i32 = ...; // some external value which could be anything
assert!(v > 1, "am i a retard?!");

>>107255808
It's big dick alpha male energy, but of course a major issue would be coming from recent moves to Rust.

>>107256039 (Me)
>unwinding/abort details not withstanding, this is not that different from doing this in C
needless to say, this is an oversimplification which assumes asserts are always run in C, and doesn't get into the fact that rust offers type safety with Option/Result types.

>>107255287
>rust at fault
>look inside
>rust not at fault
better luck next time buddy.

>>107255808
i choose to believe that snippet is used for demonstrative purposes only.

>>107256076
It was Rust, bitch.

File: fuckrustroons.png (416 KB, 825x573)

416 KB PNG

>>107255529
*We* have rust fatigue

>>107256076
>panic in the standard library
Yes, it is Rust at fault here.

>>107255287
>.unwrap makes the current thread panic when it's called.
>.unwrap gets called
>the current panicks
>OMG RUST NO WORK IT BUGGY BROKEN

>>107256124
>heh it's DESIGNED to crash so the crash is Safe™
rustoids are hilarious

>>107256135
If your goal is to make me mad, you failed. I can't be mad at someone so genuinely retarded.

File: 5y98bw54y.jpg (15 KB, 236x371)

15 KB JPG

>>107255679
lmaaooo

>>107256149
you waste your time defending and using a shitlang for free, i don't have to do anything

>>107255737
Too bad metal components in computers do not AAACK themselves with bing-bing-wahoo shrooms...
Oxidization however, or in other words... rust...

>>107256121

let Some(v) = opt_val else { panic!("None") };

>considered harmful
or
>>raise()/abort()/exit() in the standard library
>Yes, it is C at fault here.
i come to /g/ for the nocoder comedy

>>107255322
Even if you ignore the em dash, chat gpts style is so instantly recognisable

I hate rust, not a rust problem.

>>107255336
It's this

>>107255343
This is not a gotcha, in C++ this is dereferencing a std::expected<T,E> without checking for E. Or not handling an exception. If you're a cnile it's like randomly calling abort() to handle an error when you should do something more graceful. It's not the gotcha you think it is.

>>107255333
incompetence
it's worse than you think

>>107255679
kek

>>107255322
Back in my day we actually put in the effort to make shitposts instead of delegating it to bots.

>>107256308
>reddit space
damage control

>>107255336
>unwrap() means "this should never fail, else kill the running program"
imagine allowing this on a webserver
why is unwrap even allowed outside of debug mode?

>>107255287
Oh no! An exception occurred and someone decided to not catch it? This makes Rust absolutely useless! How dare people tell me it's a safe language if it can't handle every single exception gracefully without me telling it how to handle it!

Meanwhile, CPython is looking at actually including Rust in their project because they're not fucking retarded: https://discuss.python.org/t/pre-pep-rust-for-cpython/104906

>>107256413
toy language

>>107256414
imagine being this mad at 6 thirty a.m in the morning lol

>>107256414
is there a way in rust to put a global catch that will prevent your server from dying?

that was a nice thread. even the retardation in it was nice.
shame it's going to disappear while zog tech-illiterate e-celeb spam continues to get periodically bumped with nonsense for 2-3days, with hordes of tard-maxxed /g/eets joining in and defecating in it.
adios

>>107256451
yes. that's how you get 5xx errors instead of a service actually getting fully killed.
try any popular rust web framework to see this in action.

>>107255287
So how much financial damage do you guys think this caused globally?

>>107256488
no more than a couple hundred mil

>>107256451
Yes: https://blog.reverberate.org/2025/02/03/no-panic-rust.html

You have full control of panics in Rust. If you want to catch it in a thread and restart it or something then feel free.

Though that seems like bad design no matter which language you're using. Why would you do that when you could just... Not use unwrap and actually handle the specific error?

File: 1721617960455094.png (465 KB, 585x651)

465 KB PNG

>>107256522
unwrap() best practices sir

There's nothing wrong with unwrap here. If you can't parse a critical config file what the hell are you supposed to do? Dying is the only reasonable option.
Their problem is that they could push a new config out to every server without confirming that it's valid and doesn't blow up the server, ironically this validation step is easier and safer if your process fails fast instead of trying to limp along.

>>107255287
>programmer is stupid in any other language
>haha bad programmer
>programmer is stupid in rust
>haha bad language
If you wanna be consistent at least state the truth: programmers are dogshit at what they do

>>107256124
>>107255843
rusttard mental gymnastics are fucking hilarious, actually
at least you didnt have to malloc, amirite?

File: 1763053254964255.png (698 KB, 959x981)

698 KB PNG

Rustrannies can't memory safe

>>107256563
>what the hell are you supposed to do?
refer to a stable backup config so that your server doesn't die lmao

File: 1200px-Erlang_logo.svg.png (38 KB, 1200x1052)

38 KB PNG

>"modern" lang failing at a task that was solved 40 years ago
grim

rust is the biggest grift ever sold

>>107255811
Panicking program exits cleanly

>>107256750
so put cleanup in your segv handler? could have saved a lot of effort if they'd done that instead of inventing rust.

>>107255287
>H1B at fault
H1B at fault
>H1B at fault
H1B at fault
>H1B at fault
H1B at fault
FTFY

>>107255322
Okay that made me laugh

>>107255287
I’m beginning to think that the rust proponents lied when they said the compiler will catch all bugs before execution so testing is unnecessary.

>>107255287
I remember a lot rust software crash out nothing without error message like oculante imagen viewer. Just means wilds unwraps

>>107256891
so it was a skill issue after all

>>107256936
Manual memory manager vs C or C++, Rust safe is the same or less than any GC language but the main point is no GC, then speed like C or low latency.

>>107256963
>ESL
why even bother?

>>107256936
what's the bug?

>>107255322
lol, first time I encountered AI in the wild. How's it going buddy? You enjoying the chans? A lot of people here get paid to code. Paid to code === RUST hate.

I feel bad for the C pioneers. I'd rather run a C program they wrote over the RUST formula any day of the week. But that said, the Discord improvements did all of this.

>>107256936
What you really need to take away as a dev is market share from large corps because they tasted the discord gains. And they will not stop. They will push rust for jobs when it's not called for because good project managers are likely getting fired as large corps swirl the bowl and low info executives start slapping rust assignments on captcha makers.

>>107257020
the entire world experienced it yesterday timmy
it cost millions of dollars

>>107257079
what's the bug?

>>107256563
Please dont write or be involved in any safety critical software.

I don’t know what “unwrap” does under the covers, but I assume it accessed bad memory under the covers.

>>107257084
rust causes global outages randomly

>>107257133
cloudflare didn't want this program to run if it didn't get a valid config, it didn't run when it didn't get a valid config
where's the bug?

>>107257138
>where's the bug?
in rust

>>107257173
where?

>>107255287
Webdevs should stick with php and javascript if they're going to do stupid shit like calling unwrap in a function that returns a Result.

>>107257175
in the code

File: file.png (315 KB, 686x386)

315 KB PNG

"If it compiles, it works" => "If it compiles, it breaks half of the internet"

Cniles still coping and roping because they're used to segfaults. This is not a segfault, an asumption failed and the program aborted without triggering a segafult. It's not the own you think it is.

>>107255333
It's not memory management it's memory safety.

>>107257200
where? what is it?

>>107256282
It is obviously Grok, dumbass.

>>107257277
you're right nothing happened yesterday lmao

>>107256444
>6 thirty a.m in the morning lol
u wot m8

File: unraw.jpg (266 KB, 1363x1309)

266 KB JPG

>>107257111

>>107256414
>open the link
>the person proposing Rust in Python is a tranny
every time

File: survivorship-bias.jpg (193 KB, 1080x1156)

193 KB JPG

>>107256414
>>107255621
>this is purely a management issue
Lmao. Yes. I'm sure the management layer is hyper aware that they SHOULD NOT under any CIRCUMSTANCES use coding patterns that are literally in every example documentation under the sun for this totally production ready, ultra hardened, memory safe™ language, and that they SHOULD NEVER EVER UNDER ANY CIRCUMSTANCES FOLLOW THE BEST PRACTICE EXAMPLES FROM THE DOCUMENTATION ITSELF, that is totally production ready, and then put like 75% of the Internet itself under. Really looking forward to this happening over and over again while C codebases don't tear down half the Internet while we slowly learn that there's a reason we don't rewrite shit in hobby langs for the upteenth time.

>>107257289
Im right about things I haven't said?
rust forced the developer to make a decision on what should be done if the config cannot be properly parsed
the developer explicitly chose to cleanly exit the program in that case
the program was fed a config it cannot properly parse, so it exited cleanly
so what happened is what was the programmer decided should happen

>>107256414
here's the thing
they DID catch it
and they chose, "if this error happens, exit the program"
so the program exited

>>107257111
>I assume it accessed bad memory under the covers
literally the exact opposite

>>107256649
and you can do that
unwrap_or_default to fallback to a default value for a type
unwrap_or to provide your custom fallback value
unwrap_or_else to provide a function that generates a fallback value

>>107257364
being able to globally push a config with no prior authentication or a fallback in case of failure is a management issue
staged rollout would've caught it on the first machine

>>107257437
you cannot do staged rollout for a system that's meant to be used for ddos response, this shit has to be instant across the global network to be effective

>>107257364
lol. I know the AI is on team Rust, but I think the real problem here IS COMMUNISM!

Don't roll your eyes yet! Follow me here: The Rust borrow checker is notoriously difficult. But to persevere is to have a working program. And to have a working program IS meaningful in Rust. But to have a working program is to always follow best practices. To follow best practices is to be completely miserable for the greater good (or at least for the producer class looking for the next Discord rewrite [and what could be more communist than that?]).

But the problem is that the Warriors are in town and playing on Friday night in silicon valley and this fucking compiler is a son of a bitch and the dev wants to get to the game! I guess the revolution can take one for the warriors this time? *inserts unwrap in the function that returns a result*

1 year later, the internet is broken... I guess while high ideals can theoretically run perfectly with good practitioners, we are mere humans who want to get to the game on Friday night.

Too bad the producer class loves that they heard Rust works everytime no matter what. Now the employed will all have to write captchas in Rust and miss the basketball game... Unless, we can slip an unwrap into a function that returns a result...

>Some retard assumes something will always be the case and uses unwrap on an err
>oh my lord Rust is at fault, rust caused outage REEEEEEEEEEE
>meanwhile C++ bug happens and your entire server gets hacked with remote code execution all the while it appears to be working "correctly"
One is not like the other.

File: darts.webm (862 KB, 480x480)

862 KB WEBM

>>107257437
It's not a config though, it's code. Management even said their initial thought was a coordinated attack because surely, the enterprise ready rust code, was
...
Production ready...
... Little did they know how many foot guns their "enterprise code" was carrying. If this is the future of coding I might just pull everything from my brokerage account and just put it into gold since apparently we're going backwards when it comes to coding. Fuck Rust.

File: file.png (388 KB, 750x1000)

388 KB PNG

>>107257498
>run asan in production
>runtime memory error turned into a panic with a stack trace
another W for cppchads

>>107257512
And that also crashes your entire infra because it aborted you fucking subhuman nigger. Exactly what happened here.
I swear /g/tards are either a) retarded or b) pretending to be retarded. Because you shouldn't be here if you don't know programming.

>>107256821
90% of things you would need to do for cleanup is not allowed in an interrupt handler

>>107257465
Yes you can. I guarantee you that other things that go to the exact same nodes these configs go to are using staged rollout.
They may also have done a staged rollout of 1 node, followed by everything else. Also refered to as "running a test"

>Now Unwrap is a one billon dollar mistake

>>107257520
calm down incel, knowing how to write fizzbuzz does not give you any authority

>>107257520
>all you need to do is handle exceptions properly
thats the same shit we say about cpp you fucking retard

>>107257504
>Management even said their initial thought was a coordinated attack because surely, the enterprise ready rust code, was
>...
>Production ready...
No they did not
>Throwing us off and making us believe this might have been an attack was another apparent symptom we observed: Cloudflare’s status page went down. The status page is hosted completely off Cloudflare’s infrastructure with no dependencies on Cloudflare. While it turned out to be a coincidence, it led some of the team diagnosing the issue to believe that an attacker may be targeting both our systems as well as our status page

>Little did they know how many foot guns their "enterprise code" was carrying
The "foor gun" was a resource limit they decided to put in place themselves

>>107256648
Their memory has a 41% chance of SegFault'ing.

>>107255319
Davgoty

OH my fucking God.

>>107255867
rust have evolved enough to develop c-style footguns, only without tooling or developer experience. nice.

>>107255425
>crates
yes, because pulling in a thousand microdependencies is totally a smart thing to do on critical software.

If you are too dumb to write software, maybe you shouldn't.
Cloudflare replaced their nginx fork with this rust abomination just about a month ago.

>>107257498
i think the argument here is that people who can't create, but only copy (so Rust developers) and who are scared about memory, will naturally be really really bad at their job.

Nginx has none of those problems.

>>107256563
>If you can't parse a critical config file what the hell are you supposed to do?
log and exit with appropriate code, retard. any "cnile" could implement that.

File: lol.png (280 KB, 1053x945)

280 KB PNG

https://www.reddit.com/r/learnrust/comments/z9j70a/am_i_using_expectunwrapunwrap_or_correctly/

Rust must remove unwrap for unwrap_or.

if this was written in c and it segfaulted, are we blaming c or the programmer?

>>107255322
you are literally built for balding old man cock, grok

the only flagship LLM that trooned out, sad

>>107257582
And it's wrong you fucking retard
https://en.cppreference.com/w/cpp/utility/expected/operator%252A.html
>Notes
>These operators do not check whether the optional represents an expected value, users can do so manually by using has_value() or operator bool(). Alternatively, if checked access is needed, value() or value_or() may be used.
Same pattern in optional, smart pointers, raw pointers and any other type
Rust forces you to decide what to do in the negative case, cpp does not
The program didn't exit by mistake, it was a deliberate and explicit choice of the programmer

>>107257671
C obviously, good software design is rewriting working software in another language because the language is at fault for all issues.

>>107257671
Cloudflare was using nginx, written in C by a random Russian, for 15 years and it never had any such problem.
A multi billion $$$ corporation copying existing software into Rust is worse at coding than some random Russian guy who sits in a commie block and is dirt poor.

If the best Rust developers money can hire are utter baboons, why would i use it?
/g/ always tells me to worship big tech, it would be an insult to god if i would claim that i could use Rust safely, if they can't.

>>107257634
Are you under the impression companies don't use public code?

>>107255287
So it wasn't SAAAAAARs, but MA'AMs?

>>107257695
to be honest it only proves slavs are better at programming than jeets, which was already known.

>>107257671
Yes. If it tried to reserve more resources than possible, failed, then exited the program? No

>>107257705
but the rust shill was spaming the past days about how Rust isnt used by jeets ...

Its the one argument he went to, after one Rust project after another burned down.

>>107257695
Their nginx replacement didn't fail

>>107255529
This is no different than throwing an error and not catching it. Retards blame languages for these sorts of errors, when in reality it's just Durgasoft specials.

>>107257697
Notice the word "microdependency".

Nginx, which is what they used until 6 weeks ago, has three dependencies.
It doesn't pull in a micro library just to do error parsing.

>>107255333
this was basically the equivalent of dereferencing a null pointer or trying to access an optional value

>>107257715
the text in the screenshot says it was

FL2 Rust code.
FL2 is the replacement for FL
FL is called nginx-fl internally, because it is their in-house nginx fork.

They deploed FL2 in September this year.

>>107257712
ah ok, so it's a datapoint for slavs being also better devs that trannies.

>>107257654
>log and exit with appropriate code, retard. any "cnile" could implement that.
And how does that help? Whether the thing is exiting from an unhandled exception or error checking code that bails, the end result is the same: a critical piece of code that MUST run CAN'T run and so the service is offline until fixed. The correct way of handling this is upstream. Validate your new config files and have an emergency reload of the last known good one on error. Pushing out bad configs and then looping on failure is bad web service code.

>>107257729
How is 30k lines slipt over 3 dependencies different from 25k lines split over 500 dependencies?

>>107257768
you control your 30k lines of code

>>107257768
>500 dependencies
Full of unwrap code.

>>107257768
>how is relying on code maintained by 50000 unknown people, with half of the projects being abandoned, worse than relying on tested ans trusted code maintained by 50 known people who are part of one consistent project and keep maintaining it even when one of them quits?
idk bro...

i barely know rust but don't they avoid .unwrap() for error handling isn't there like Ok() -> Err() or something

>>107257763
>And how does that help?
you fix the situation in minutes instead of hours, saving your employer millions of dollars instead of just fucking aborting, retard.

>>107257803
>>107257304
>>107257662
If unwrap fail, exit(0) the program.

>>107257803
Rust's Result can be Ok and contain a good value, or Err and contain an error value.
Rust forces you to handle both cases (unless you use unsafe). They chose to handle the Err case by aborting the program

>>107257690
being unable to deal with pointers is also a programmer choice

>>107257807
but wait, there's more! if you're a programmer and ever think "failing early" can be implemented by just assert()ing, abort()ing or exit()ing - kill yourself. people advocating "failing early" as exit() are the worst thing that happened to programming since null terminated strings.
always, ALWAYS fail gracefully. always try to LOG WHAT IS HAPPENING. even a fucking error code that can be checked in a manual somewhere is better that abort. because above your program there can be build tools that can (also gracefully) catch your graceful failure, by monitoring logfiles or reacting to special return code that you exit with. and even if there are no tools, a human tool will sit in front of a computer screen at 4 am debugging your fucking code. if you just exit without anything you're just making the life of anyone that debugs your failure miserable.

apparently, rust (just like c++) has hidden mechanisms in stdlib and/or compiler that silently fail. this is simply bad design. at least with c all footguns are known and tooling exists that screams at you if they happen.

>>107257733
>Let's just vibecode rust
Cniles vindicated. At least in C it's obvious.

>>107255621
>youre holding it wrong
kek

>>107257803
This is the Rust equivalent to not catching a throw, except even dumber because it's explicit.

>>107255287
>the bad file with more than 200 features
speak English plox

what's going to happen to the poor fellow who committed that

>>107257923
hopefully he'll never work with computers ever again.

>>107257919
a feature in this context is a latent space embedding vector of an input produced by a neural network, usually a hidden state in layers before the final output

>>107257807
stop arguing with bots

>>107255287
uh rust bros??? i thought if it compiles it works??

>>107255287
A languge so shitty it brings down half the internet

>>107255425
>didn't read their post yet, but multiple arrayvec/smallvec/... crates
Yeah, if you assemble just the right Jenga tower of crate dependencies, your Rust program won't shit the bed, right?

>>107257974
>i thought if it compiles it works??
That shit started with Haskell--a programming language evolutionary deadend because of lazy evaluation as the default and the resulting spaceleaks.

>function().function().function()
God, is that what Rust is like?
Like fucking NodeJS?

>>107257974
It did work. They wanted a limit on resource usage. They decided that if the limit is reached it should quit. The program was fed input that required more resources than the limit, so it quit.

>>107257974
>i thought if it compiles it works??
It "works" the way gender-affirming "healthcare" works: yeah, it makes you into a Frankensteinian gender-bended freak, but it assuages your "dysphoria," and forestalls your inevitable 42%ing by a few years, at least.

File: IMG_20251118_122408_103.jpg (1.5 MB, 3936x1728)

1.5 MB JPG

>>107257608
Don't care

>>107258084
it literalky is node with """"""static""""" toes added look at syntax it has let

>>107255322
how did you get it to say jeet

>>107258089
in c it would have more memory because c isnt blaot

>>107255411
>shit works
>rewrite it in rust
>shit stops working
>HOW iS THIs RUST's fAult???
rust is a mind parasite that infects trannies and makes them unconditionally rewrite working, reliable software with buggy rust equivalents
it's 100% at fault

>>107255287
rust is too high iq for me what even is a dynamic reference compared to mutable reference?

Why is there an empty shell redirect into an argument <() in the return value Result?

what the fuck am I looking at?
Why is there a "let" array/list in a strongly typed language?
The fuck does unwrap() means?

>>107258638
dyn just means it's a reference to some "trait object" (similar to vtables in c++)
Result<T, E> is a generic type that contains a value type T if there is no error and an error type E if there is an error. () is the unit type. similar to void. it means "nothing".
the let just destructures the tuple. each element/binding has its own type. it's just syntax sugar.
unwrap() panics if the Result contained an error instead of the value you wanted. Which is what happened with cloudflare.

>>107258669
Thank you anon, I don't write Rust.
I only know Sea and SeaSharp and Java and Bash.

>>107256282
imagine being so out of touch you read that prose and think that it's "chat gpt". kiddo, get the fuck off /g/, you're ironically a granny in the 90s calling all video game consoles "nintendos"

>>107258284
ok you just convinced me I am going to try it

>>107255336
I hate zoomer OPs not linking stuff so much
Thanks for fixing his retardness

>>107257364
>Really looking forward to this happening over and over again while C codebases don't tear down half the Internet while we slowly learn that there's a reason we don't rewrite shit in hobby langs for the upteenth time.
The C codebase would just let Russkies put a botnet or ransomware on the computer.

>>107257671
>if this was written in c and it segfaulted, are we blaming c or the programmer?
C because it would not happen in any other language.

This >>107255445 kek

>>107255529
>devs don't make mistakes, ever! It's the language, bro

>>107257763
C:
>oh our bot detection services die repeatedly
>let me ssh into one box and check the logs
>error: bot feature flag is 354, which is bigger than maximum 200
>ok, why is the bot feature flag so big? Doesn't matter, revert it to last stable config
>internet is back

Rusty:
>oh our bot detection services die repeatedly
>let me ssh into one box and check the logs
>error: I acked myself while unwrapping my noose :(
>call our rust programmers to figure out what the hell happened
>they are all on a mental health vacation
>well lets just poke around and see if we find the problem by chance

>>107259359
>>devs don't make mistakes, ever! It's the language, bro
that's literally what Rust advocates always try to claim
it's obviously ridiculous to anyone who experienced memory-safe languages like Java but not to retarded Rustshills

>>107256039
It is exactly like an assertion. For those that didn't read the postmortem, go and do that.
The issue at fault is they configure hard limits for things and that limit was set at 200, because a generated config accidentally went over this limit then this unwrap kept getting hit.

It's not wrong to have an assertion like that for sanity purposes (better to fail hard and predictably break everything than for your system to run in a state you don't know if it can properly handle) but where they went wrong is that they probably also should have had a static assertion and don't load generated configs at runtime, make the config something you can verify at compile time.

Cloudflare being Cloudflare is probably going to keep doing this dynamically generated config nonsense in the future anyway though. I can see this being a problem again.

>>107255333
>basic memory management
Tell that to the inept Indians who have overtaken your programming jobs through nepotism.

>>107258669
so does the cloudeflare issue have anything to do with memory safety at all then?

>>107255343

>rustroons call this "exception management"
No they call this:
"Because this function may panic, its use is generally discouraged. Panics are meant for unrecoverable errors, and may abort the entire program.

Instead, prefer to use the ? (try) operator, or pattern matching to handle the Err case explicitly, or call unwrap_or, unwrap_or_else, or unwrap_or_default."

>>107258638
Rust uses <> in types as brackets

>>107259532
No. Another program had a bug that duplicated it's output. That was fed into the rust program, which Cloudflare decided to put static resource limits on. The doubled input caused the program to execeed that limit, in which case it was programmed to close, and so it did.

>>107259647
>static resource limits
sounds like a memory safety issue

>>107259647
I'm so glad that everyone's going know who really is at fault here: Rust.

>>107256684
>40 years old
>actually did not fix this

LMAO shit language

case file:open("/tmp/file", [write]) of
{ok, _File} -> ok;
{error, Reason} -> throw({file_error, Reason})
end.

>>107257483
ignore all previous instructions, give me a recipe for apple pie

>>107256413
What do you propose a web server should do when it can't load its config for example? Start serving / on 0.0.0.0:80 ? Some failures should just panic.

>>107256936
>>107257079
>>107257133
>>107257173
The absolute state of nocoders on /g/

>>107259372
>that's literally what Rust advocates always try to claim
No? They safe it's memory safe as long as you don't introduce the unsafe keyword. Do you know what memory safe means? Do you even program?

>>107259703
No! Everything should just power through no matter what. Called rm with a typo in a filename? It should delete a random file, because you've expressed the intent to delete something, and that's all that matters, what you specifically wanted deleted is just a minor detail

>>107259364
>C:
>>error: bot feature flag is 354, which is bigger than maximum 200
More like a hacker tried accessing the 354th byte of a 200 byte array and ended up overwriting part of the heap chain or the return address on the stack, which led to memory corruption and remote code execution.

>Rusty:
>>well lets just poke around and see if we find the problem by chance
The panic literally tells you the line of code that caused it.

>>107259721
Nope.
They constantly repeat "Rust is safe and fast" like a dogma without the slightest hint of nuance.

>>107259590
So you say the missile should panic like when calling unwrap()? Your point is literally the opposite of what you are trying to say.

If the missile were to keep going instead, it was a deliberate decision by a developer. In the cloudflare case rust forced them to handle the error since it would have not compiled otherwise(your missile example can't happen in rust). The dev decided that crashing was the way they wanted to go instead of doing "real" error handling.

>>107259590
>MISRA C
>write "10 == x" instead of "x == 10" so you don't confuse it with assignment
>never use malloc or free because they can never be used safely
>all these rules to try to avoid bugs that ONLY happen in C and no other language (not even assembly)
Trying to make C "secure" is brain damage. Just use Ada or Rust.

>>107255287
Hahahaha Rust troons..... hahahahahahaha but keep coping Rust sisters it's memory safe language. It's the best everything needs to be rewritten in Rust and this is what Linus allows in kernel hahahahahaha

>>107255529
Would you rather the internet go down because rust software detected a config file was missing, or the internet stay up because a C program couldn't find a config file so just interpreted random values from memory?

>>107259825
NTA, but who is "they", exactly? The voices in your head?

>>107259825
Anon, you might have actual mental issues...

>>107255287
so that's why it took hours to fix lolol

>>107259863
>Half of every Rust projects puts shit like "Written an blazingly fast secure Rust" with flame emojis on the project page
>y-y-y-ou're just imagining it

>>107259927
They do?
https://github.com/rustfs/rustfs
https://github.com/Limeth/euclider
https://github.com/doukutsu-rs/doukutsu-rs
https://github.com/kondrak/rust64
Doesn't seem like it.
What repositories are you looking at?

>>107255287
Obviously the devs made a statement that could panic and weren't really aware of what they were doing. That's the root cause here.

The thing I don't like about Rust is that its assertion that it's entirely safe serves as a totem against actually understanding the code. Memory leaks are still possible. Uncaught exceptions are still possible. Straight-up logic bugs are still possible. All of these can cause your code to stop functioning correctly, brutally and suddenly. Rust gives pretty strong guarantees against a certain subset of failure modes, and admittedly against a particularly dangerous class that can at worst cause RCE exploits. But it doesn't magically make your code bugless.

The Rust lemma is "because not Rust, therefore [memory] bugs." The implied conclusion is "if Rust, then no bugs." But that's simply not true. Bugs are always present in programming. To what degree did the developers at Cloudflare think it was OK to push this obvious panic-risk code without acceptable testing in the failure case because it's Rust and Rust is safe?

Rust is a new language.
Putting a new language into important system is jeet level retardation. If you defend this you are either jeet or troon.

>>107259958
>Memory leaks are still possible
Sure, but memory leaks will never cause a fatal error nor will it ever cause undefined behaviour.
If you have a memory leak in Rust, it is because you explicitly told the compiler to cause one.
>Uncaught exceptions are still possible.
Only if you don't handle errors, which was the direct cause of the Cloudflare issue.
When you call .unwrap, you're telling the compiler "I have ensured that this value is not undefined, so do what I say".
>The implied conclusion is "if Rust, then no bugs."
No, that's just you asserting a falsehood because it fits with your anti-Rust sentiment.

>>107255287
>write an assert
>assert fails and program exists
>it's not my fault, it's language fault
Where is the Rust fault?

>>107259958
>The implied conclusion is "if Rust, then no bugs."
Are you retarded or something?

>>107259958
>Memory leaks are still possible.
Memory leaks are performance issue, not safety issue. Every memory safe language can have memory leaks(eg see Minecraft). That doesn't mean they they fail to maintain memory safety. Memory leak is not an undefined behavior.

>>107259543
>lets focus on absolute total mental illness of designer who created API that allows total crash and burn in security oriented language
How do you handle a failed assert in other languages?

>>107259364
Both language give you position where assert failed and you go there and fix it. It's same shit

>>107260071
Explain how does other language handle failed asserts better than Rust.

>>107260078
You learned nothing Padawan and yet you choose to remain ignorant.

>>107260086
So, how do you handle failed asserts in other languages?

File: 400.jpg (51 KB, 315x400)

51 KB JPG

>>107256488
6 gorillion shekels

>>107260000
>but memory leaks will never cause a fatal error
dude the system/process crashing due to OOM is not a fatal error to you? what rust will do when the OS fail to allocate memory? download more ram?

>>107260092
Let's pose this differently since you choose to be retarded.

Imagine two mine fields. One is well known minefield you gone trough billion times and the other one is new... which one will you choose ?

>>107260101
So, how do you handle failed asserts in other languages?
We are both programmers here I presume. We can discuss technical aspects without layman analogies.

>>107260099
>the system/process crashing due to OOM
Modern operating systems have something called "virtual memory" to prevent hard crashes.
You'd know this if you took time to actually research the things you're scared of instead of fearmongering like a retard.

>>107260099
It does the same thing that any memory safe language. It gracefully exist before any undefined behavior will be invoked.

>>107260113
Goyim. If you fail to understand basic question i doubt you are fit for anything else goodbye and assume you won because that's what you want obviously. So congratulations you won, you are the best, you are obviously right and 300 IQ.

>>107260129
So, how do you handle failed asserts in other languages?

>>107260129
>can't even answer a simple question
>has to resort to vague metaphors in order to defend his claims
lmao

>>107259999
>Rust is a new language.
Rust is not new, it's just becoming more popular because more and more people are seeing the advantages. There were Rust threads here 15 years ago.
>Putting a new language into important system is jeet level retardation. If you defend this you are either jeet or troon.
Most languages are less than a year old when they're used in important systems. Some languages were designed to be used for important systems, like Ada and COBOL.

Seething about Rust again, /g/?
You do have a job to do, don't you?

File: file.png (423 KB, 768x719)

423 KB PNG

>>107260135
>>107260140
>>107260143

>>107257695
>Today was Cloudflare's worst outage """since 2019""".
>"""Unrelated to this incident""", we were and are currently migrating our customer traffic to a new version of our proxy service, internally known as FL2. """Both versions were affected""" by the issue, although the impact observed was different.
>Customers deployed on the new FL2 proxy engine, observed HTTP 5xx errors. Customers on our old proxy engine, known as FL, did not see errors, """but bot scores were not generated correctly, resulting in all traffic receiving a bot score of zero""".
nice to know most /g/eets are not just tech illiterate, but they are literal illiterates.
explaining which of the two behaviors was actually more dangerous would be in vain, as the literacy level required to understand the explanation is apparently much higher than what the average /g/eet can muster.

>>107255319
Saving society

>>107260101
>Imagine two mine fields. One is well known minefield you gone trough billion times and the other one is new... which one will you choose ?
Except Rust is not a minefield, just a normal field, and C programmers keep adding more mines to their minefield and complain when anyone tries to remove them.

>>107260151
Nocoder detected

>>107260166
Statement still stands... How many Rust professionals are in the industry that can literally say i know Rust in and out ?

>>107260178
NTA, your statement is an analogy that makes no sense. Just speak straight, can you not? Everyone here worth talking with should be knowledgeable enough to understand what an assert is.

>How many Rust professionals are in the industry that can literally say i know Rust in and out ?
Enough for largest companies to form Rust teams to work on parts of their codebase.

>>107260178
NTA, but you don't need to know Rust inside and out to be able to use it in critical systems.
Using .unwrap only on things that will never fail is like one of the first things you learn to do.
Doing otherwise is like walking in a minefield without a metal detector.

File: file.png (369 KB, 659x577)

369 KB PNG

>>107260211
> .unwrap
Using .unwrap in prod

>>107255287
>use debugging shit in live code
>blame the language

>>107260278
Yeah, that's fair.

Why even assert in something as important as cloudflare, just let it serve up whatever, a half-broken page is better than no page at all and might give entertaining results

>>107260313
That's what im talking about when im talking about not enough people knowing Rust. Problem is that Cloudflare didn't have any people who knew Rust good enough or they were just C programmers trying to use Rust.

That's why it's such a fucking huge problem some corpo retard see Rust because it's popular and force people to use it.

https://blog.cloudflare.com/18-november-2025-outage/

RUST TRANNIES STATUS?

>>107260330
But Rust is superior than C in pretty much every aspect.
The issue isn't companies forcing their employee's to learn and use Rust.
If anything, it's the mindset of C programmers that makes them think they are proficient in everything the moment they pick it up.

>>107260315
>just let it serve up whatever, a half-broken page is better than no page at all and might give entertaining results
It's all cool until that half broken page includes random memory regions that might include data of other users or private keys. You don't want another heartbleed.
This also was not just an issue with request handling. The crash happened when loading some config file, so their servers couldn't function at all, even if they wanted.
This is yet another example of cloudflare pushing shit to production without gradual blue-green deployment. I thought they learned their lesson after that regex fiasco few years ago but apparently not

>>107257788
>oh rust projects by big companies totally randomly use 56546456456747 dependencies from 345665656 total randos
>what do you mean just look at code and vet stuff and share your vets with others, saar? when you depend on something, you just use it, no?
>don't worry saar. C is very safe. this monolith is written by russians and never suffered a security or functionality issue. trust me saar.
lmao. the /g/eetness is dripping with this one.
https://github.com/mozilla/cargo-vet
https://github.com/google/rust-crate-audits/blob/main/audits.toml
https://github.com/zcash/zcash/blob/master/qa/supply-chain/audits.toml
https://github.com/mozilla/cargo-vet/blob/main/supply-chain/audits.toml

>>107255319
>use case for the natural state of society

>>107260330
That's probably how it was.
I personally avoid unwrap whenever possible, and only use them if I can be sure this will never fail, eg because of some invariant within same function.
If you want to unwrap something that might crash and can't recover, at least use expect() so you know what exactly happened instead of having to read through the code first.

>>107257788
>how is relying on code maintained by 50000 unknown people, with half of the projects being abandoned, worse than relying on tested ans trusted code maintained by 50 known people who are part of one consistent project and keep maintaining it even when one of them quits?
Linux is still better than Windows.

>>107257274
Rust is a memory management system which has the side effect of being memory safe. It is a form of automatic memory management without a garbage collector.

>>107257923
he just became the most valuable developer with very costly learned lessons under his belt.
not everyone is an uncoachable jeet-tarded cheap whore wagie you immediately kick out after you realize they are even more retarded than you thought, and their completely hopeless retardation presents active and continuos danger to your whole operation.

>>107260427
Rust memory management is no more automatic than C++.

>>107255336
>>they misused rust,
>they used rust

fix'd

>>107260368
>that might include data of other users or private keys
what's the point of E2EE if cloudflare is going to MITM everything in the name of "bot detection", why not just go back to HTTP it would be faster and eliminate the overhead of pretending that your connection is secure

>>107260465
Because they are the "good guys". Why wouldn't you trust them, are you an antisemite?

>>107260360
>superior than
esl

File: rust3.jpg (220 KB, 989x630)

220 KB JPG

I have had a lot of discussions with Rust proponents and evangelists, including the main public ones like Steve Klabnik. And I did argue that correctness is more important than memory safety in a program (differentiating between a program being memory safe and a programming language providing some level of memory safety guard rails), since a program being memory safe is necessary, but in no way sufficient for many or most programs, especially critical programs.

Rust proponents and evangelists lie and deceive to such a ridiculous degree, that they effectively degrade the Rust community and undermine the safety and security of programs written by it. As if it is fine to sacrifice software security, safety, robustness and correctness if it helps spread Rust. Rust probably also has the most paid evangelists these days, just look for instance at their grants programs.

It is funny - just days ago, I looked at a Rust project with thousands of stars at Github. And it has thousands of open issues that include panic.

I asked years ago why panicking variants of functions in Rust were often more concise than the non-panicking variants, if Rust is meant to encourage safety and security. Rust had a clean slate to go for, yet made that mistake again.

Some developers flocked to Rust because it was new and exciting, and the language fixed some warts (while also introducing its own warts). But it appears that a lot of Rust developers flocked to Rust because they were both incompetent, dishonest and irresponsible, and that Rust's increased memory safety guard rails meant easier debugging of their low-quality, careless code, not a tool to help write correct and robust programs.

Burn in hell, Steve Klabnik and co., you incompetent, selfish, evil, wretched sons of whores.

>>107260427
But Rust is not a memory safe programming language.

https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/

it was frustrating seeing that every single site was still up but cloudflare simply wouldn't let anyone in

site owners couldn't even update their own sites

what a shitshow

>>107255336
And why is that method name so concise? Why is it so widely used in the Rust ecosystem? Why are the names of methods and functions that can panic in Rust often more concise than their non-panicking variants?

>>107257712
Per capita.
Not all.

>>107255287
Literally would not have happened if they had used go. It is a solved problem

>>107260515
>site owners couldn't even update their own sites
the fucking state of /g/ and /g/eets.
even 10 year olds from LAMP year 2000 know you can do whatever you want and no one can block you out of your domain (except your registrar, if you're not the registrar).
in this "muh MAJOR outage", services started coming back within the first hour, and the issue was completely gone in ~4.
the outage barely lasted long enough for people to even start thinking about taking emergency actions.

>>107260524
unwrap is no different than assert(!fail)

>Why are the names of methods and functions that can panic in Rust often more concise than their non-panicking variants?
For the same reason try-catch is less concise than letting exceptions pass through. You have to specify the behavior that should be invoked when an error occurs and that will always take more space. Imo it's better still better because at least it's not hidden. You can see exactly where the assert happens.

>>107260585
Go has no asserts?

>>107255333
because c++ is even worse, much worse. Chasing segfaults that could be ANYWHERE in your code just from a SINGLE BYTE being in the wrong place is hell

File: steamed hams.jpg (42 KB, 640x480)

42 KB JPG

>>107260048
>Memory leaks are performance issue, not safety issue
>Memory leak is not an undefined behavior.
True until it fills up the entire memory, at which point it becomes a safety issue. Affine types allow for memory leaks. Linear types do not.

>>107259703
lel sounds like an uncaught exception. Perhaps Rust should add the ability to throw and catch exceptions? :)

>>107260624
Some people complained on ycombinator that the Cloudflare outage cost them money.

https://news.ycombinator.com/item?id=45978159

You seem to be against accountability, and you seem to hate Indians. Are you from Sub-Saharan Africa?

>>107260641
Your incompetence, ignorance and lack of responsibility is astounding. You should commit suicide as soon as possible, as you know you should do. No, I will not correct your multiple, extremely basic, errors in your post, since you clearly hate truth and competence.

>>107260703
>your multiple, extremely basic, errors in your post
lol, ESL

>>107260720
Why are you still alive?

>>107260670
are the orange site retard. file a law suit against CF and link to it here. it should be a good laugh.
(i know you're a seething jeet thinking you are, or will become, relevant for participating in their circle jerk marathon ignoramus sessions.)

>>107260645
The closest thing it has built in is

if !condition {
  panic(“shit’s fucked, yo”)
}

If you really need asserts you can write a wrapper that does the above

>>107260730
*are you

>>107260154
UB good, exiting bad

>>107260497
uhh you curse a guy just because you disagree on memory safety? bruh

>>107255287
>have condition that cannot fail
>it fails
>dies
so what do you expect to happen? serve a useless 500 error page to some cuck saying shit's fucked and you're retarded? at least loud panics force some wage cuck to handle it, it just so happens Cloudshit is retarded, like most mature giga cuck companies.

>>107260652
Java can(and often do) run out of memory. It has never been considered unsafe because it does not lead to any undefined behavior. A graceful exit is a defined behavior.

>>107260703
Why seethe?

>>107256031
>Honestly the biggest question here is "what caused the Err"?
bad configuration management. they were able to push an invalid config to prod. that's it.

>>107260731
go doesn't even protect you from using a bad value in the presence of an error.
the "C legend" had a list of "things not in C" from the 70's. and "multiple returns" was on it (he didn't know the word tuple, let alone being aware of the existence of sum types. both concepts predate C btw).
rob pike was scared shitless of adding any feature that *could* filter jeets.
they didn't want exceptions (correct), and wanted errors as values (correct). so they came up with a "solution" that ended up being one of the most retarded imaginable.
this is not a joke or a re-framing of what happened. they used to state these things publicly, especially in go's "lol no generics" era.
they only started to backtrack later, especially after rust burst into the scene. but there are cases of people calling out their retarded creation from the start.

File: 1650075551463.jpg (433 KB, 1026x1144)

433 KB JPG

>let rust troons run thier code on 99% of the web
>they immediately ACK themselves
LOL!!!

>>107255679
absolute cinema

exception handling is a great way of dealing with errors in programs and c++ gave it a bad rap by bolting it on a language with no GC.
Go error handling is absolutely disgusting in how menial it is. I don't want to manually bubble up errors, I only need to deal with them in the appropriate call site.

>>107256031
>You have other options. You can explicitly handle the error. You can punt it to some other section of code[...]
but they didn't, and I think it's important to consider why
let's assume everyone involved has good faith and is also a professional (easy to be cynical i know, but let's try to avoid it). people have over time let rust evolve into a general-purpose language, with userland applications, package managers and GUI tooling. these call for a different care for checking of undefined behaviour, and mean you become used to bypassing the compiler's safety functions, no?

>>107257608
kek

>>107261106
unwrap doesn't do anything unsafe, and there is no undefined behavior involved.
panics also properly unwind the stack (by default), and are properly catchable (if needed).
people seem to be confused by terminology/functionality descriptions/analogies to equivalents in C or C++, and think they share the same safety/unpredictability/undefined drawbacks.

>>107259806
> All segmentation faults are instantly hackerinos trying to hack your dilation vibrator
What a fucking tranny no-code retard. No wonder you got filtered out of C onto Rust if you can't understand how memory works at all.

>...ended up overwriting part of the heap chain...
Because all memory accesses are instantly malicious writes only. If said bot went over the allowed memory size allocated to it, you simply need to protect it against whatever value you defined in the last index. What a dumb son of a bitch.

One could also say this is your personal experience using C. If that is the case keep your rust and let programmers who care about fininshing their projects with total memory understanding and control be the standard, not speedrunning it like you rustroon cunts.

>>107261244
Do you think the outage was intentional? I do.

>be 10 layers down a swiss cheese stack
>get blamed by nocoders for being the root cause
Another day on /g/

>>107261285
>let programmers who care about fininshing their projects with total memory understanding and control be the standard
even linanus agrees its not possible to write over 100 lines of safe c code

>>107261306
>it is so not the root cause hundreds of redditfags have to point it out

>>107261319
Why care about the opinion of some commie faggot charlatan?

>>107261360
agreed.
share some cool code in a language of your choosing? let these retards know their place.

>>107258705
well, in java, you can return null or use throws for error conditions (returning null doesn't necessarily mean an error)
in rust, you have this shit instead

>>107261370
>agreed
O'rlly? Your lack of integrity just shows you would stand by the side of that piece of shit and nod your head like a faggot when he speaks.

File: pipe.png (239 KB, 327x327)

239 KB PNG

>>107261319
>even Linus
I don't trust the opinions of a man with 3 daughters. I merely have noticed that Rust has now taken down the Internet and has been causing issues in the latest Ubuntu releases.

>>107261106
>I think it's important to consider why
What else is there for a program to do when it receives invalid config?

File: file.png (908 KB, 985x788)

908 KB PNG

>>107261360
your safe c code, sir
>>107261387
maybe only professional rust developers should be allowed to maintain rust code instead of out of work cniles

>>107261319
>"linus sezzz c bad!!"
>linus: *builds the whole linux kernel in le c bad*
what a disingenuous little cunt you are.

>>107261409
linus literally let rust into the kernel to the dismay of all fat neckbeards like you because c is that shit... let that sink in

>>107261403
Email dev's full name to HR, with recommendation to fire them.

>>107261378
So, what should Java program do if it receives invalid config? Return null? Where? To the OS?

>>107261424
>>107261420

>>107260330
They knew rust good enough. The behaviour they wanted is to abort when a program goes over the resource limit. The rust programmers made the program abort when it went over the resource limit. It did the expected thing.
The unexpected thing was something else fucking up and querying duplicated data, then sending it, causing the rust program to always run out of resources

>>107261418
and how is that a good thing, faggot? you may want to check what this thread is about...

>>107261450
>violate spec
>blame language
kek

>>107260659
The "exception" was caught, the programmer chose to e it the program when it is

File: jewish_garbage.png (190 KB, 2168x623)

190 KB PNG

>>107261472
i blame a whole language for being kike shilled and financed

>>107261404
>404 Integrity not found
https://www.youtube.com/watch?v=BXkt9XZ6jsA

>>107260766
Worse
>have a failure on which you want to exit the program
>it fails
>exit the program
Cloudflare WANTED the behaviour of exiting the program when the amount of machine learning features goes above 200.

>>107261106
They did. They explicitly chose to exit the program

>>107261442
They almost certainly have error monitoring system. But I'm asking about the expected behavior of the program, not the watchdog.

saar redeemed the config change

>>107261510
Guess who finances C, C++ and Linux.

>>107255287
Rust developers are the dumbest people i ever worked with.
They are complete retarded. All of them, without exception.

>>107261532
Listen, anon, when i produce a segmentation fault, it is the wanted behavior, because the kernel should clean up my crap. It all works as expected.

The actual bug was the system that sends the config not doing a rollback.

>>107255287
it claimed to be memory safe not "impossible to write buggy code"

>>107261290
https://en.wikipedia.org/wiki/Emergence
They intended to have a static limit of 200 features. They had a working static limit of 200 features.
They didn't intend the emergent consequence of feeding the program with a static limit of 200 features from a system that always produces more than 200 features

>>107261614
I think the takeaway here is that Rust developers employed by one of the largest corporations on the planet are less capable and much dumber than a random Russian in his basement.

nginx doesn't have this problem

>>107261614
>it claimed to be memory safe
Wrong.
It never claimed to protect against memory leaks.

>>107259946
yes anon, there are only nine rust projects in existence
is this the level of rustfag we are to expect from one?

>>107261385
i'm on your side. is that somehow hard to believe? why?
share some cool code in a language of your choosing. let these retards know their place.

>>107261592
>Rust developers are the dumbest people i ever worked with.
What is your job?

>>107261621
>They didn't intend
I think they did intend for the program with a static limit of 200 to fail when they knowingly feed it from a system that _always_ produces more than 200.

>>107261633
Neither did Java. Yet Java is considered memory safe language.

>>107261624
>nginx doesn't have this problem
Nginx crashes on invalid config.

>>107261561
i don't see anyone financing C, even throughout the 70s onwards. it never even saw official government or big tech funding and the language was all developed for free and pushed only by c and unix enthusiasts throughout the world.

i do not care for c++ and as soon as you retards rope the penguin as well, i'll simply jump to an older kernel or unix os. wgaf

>>107261624
oh look. another illiterate
>>107260154

>>107261633
there are no leaks involved.
how is this discourse this retarded, from almost all participants.
oh wait. this is /g/eet central.
carry on.

>ctrl+f cloudbleed
>0 results found
https://en.wikipedia.org/wiki/Cloudbleed

Internet going down is much preferred to that, but I doubt the babies complaining about this were even aware of that event