Hey Rustfag

So if it isn't C or C++, it magically doesn't have UB even if said behaviour is undefined. Got it.
Aka "we're too lazy to write an actual spec so anything this compiler does is defined behaviour."

You're so fucking retarded. Even more so than C/C++.
Look at any specified language other than C/C++. Does it have UB? Protip: no

"C was originally developed at Bell Labs by Dennis Ritchie between 1972 and 1973 [...]"
"C has been standardized by the American National Standards Institute since 1989 [...]"

"In 1985, the first edition of The C++ Programming Language was released, which became the definitive reference for the language, as there was not yet an official standard."
"The C++ programming language was initially standardized in 1998 [...]"

Kill yourself, you utter retard.

Yes, provided it's an actual language standard rather than "implementation is the standard ecks dee" bullshit. Even Common Lisp has it and there is a good reason for it to exist: It gives the implementation freedom to optimize. C/C++ don't suck because they have undefined behavior; they suck because the specified part is so useless that you can't get around undefined behavior in nontrivial programs.

That's an interesting claim, unfortunately I can't verify it because the standard isn't free. LMAO
So let's take a look at other languages:
C# (ecma-international.org/publications/standards/Ecma-334.htm): 8 cases of UB, all require the explicit use of unsafe.
JavaScript (ecma-international.org/publications/standards/Ecma-262.htm): 0 cases of UB
Java (docs.oracle.com/javase/specs/index.html): 0 cases of UB
Dart (ecma-international.org/publications/standards/Ecma-408.htm): 0 cases of UB
Eiffel (ecma-international.org/publications/standards/Ecma-367.htm): 0 cases of UB

UB is peak braindamage.

if only C++ wasn't specified, it wouldn't have undefined behavior, because GCC would define it

I'm just now entering this discussion, but I can give a brief summary of the manner of undefined behaviour Common Lisp has.

Some functions aren't defined to freshly cons (allocate) a result; the result may be reused, so it's undefined what happens if it's modified. Several SEQUENCE manipulating functions accept a :TEST and a :TEST-NOT parameter; the latter is deprecated, but it's undefined what happens if you specify both for a call to such a function. A list can be circular or end improperly, but some functions may or may not detect this; it's undefined what happens if you call LENGTH on a circular list, instead of LIST-LENGTH which specifically detects this case, so an implementation may signal an error or loop indefinitely; a list manipulating function may signal an error if it's used on an improper list, but may not if it gets its result before it reaches the issue. It's undefined what happens if you manipulate a list that's been specified literally, since that may be made constant by the implementation as an optimization.

This is a summary of some of what's in Common Lisp. As you can see, it's nothing particularly unreasonable, unlike C.

I don't understand what you are trying to say.

The absolute state of anti Rust shills.
Cniles are so desperate to argue against their beloved languages deprecation that they praise the worst thing in the history of computer science.

If you aren't programming in straight asm inside a monitor program you're a cuck weenie tbh.

...