I don't know guys i kinda want code to be human readable :(

code readability is not problem we have LLMs, the problem is that even LLVM cant figure this shit out and go in circles with the borrow checker

>>105993095 (OP)
Do Rust trannies really?

>>105993128
Mozilla trannies is more like it.
Mozilla put inclusive writing(far left woke bs no one wants) in the french localization of firefox cementing their place as a woke company.
And what should one expect from a woke programming language other than awfulness?

>>105993113
I am pretty sure this is the whole point of Rust. LLM's are brain dead so they hope they can make an LLM-proof language.

>>105993095 (OP)
I love unions and pattern matching but i would rather write go than whatever the fuck this is

>>105993095 (OP)
It's a very condensed abstraction, let's try breaking it down.
On the first glance looks like try_map works on a range R and applies function f.
Now I'm sure Try and Residual traits are clickable in the doc. But it looks like the size of range R has to be known at compile time.
R has to implement the Try trait, converting R as Try has to implement the Residual Output trait.

If I were to guess, this is trying to be a fallible iterator method, somewhat anti-pattern to Rust and I can't visualize a usecase for this.

>>105993253
Probably useful for creating bindings with foreign languages/libraries.

We need a C syntax style language with a borrow checker. This trannylang should burn, no normal person should have to read it

>>105993292
it's useful if want fuel to hang yourself. I have 8 years of experience and worked with many programming languages (C#, python, F#, javascript, typescript, bash, go) and rust and c++ are the only two languages where you can look at any code snippet and it's the most arcane, unreadable, vomit-inducing trash you've ever seen in your life.

>>105993342
What the fuck is C syntax style?

>>105993345
You can write the same try_map in JS but Rust makes the behaviour explicit. In C++ you can just simply throw a bespoke `T` and it would also be implicit.
Very lame take for someone with 8 years of experience 2bhfam.

>>105993095 (OP)
There is no reason for ever writing shit like this other than stoking one's ego. Funny that it's only ever langs that claim they are the best at all things that end up shitting out crap like this. Rust and C++ are the same lang at this point.

>>105993345
This would be readable in Java.
Maybe a bit lengthy, but readable for anybody who can read at a fourth grade level.

>>105993350
Having good style. A language with perfect looks

>>105993095 (OP)
Compare that to the average MSVC STL signature.

(i'm barely awake. hopefully i don't make a retard of myself)
>>105993253
>On the first glance looks like try_map works on a range R and applies function f.
no it's not. look at the `F` bound. It's `T -> R`
>If I were to guess, this is trying to be a fallible iterator method, somewhat anti-pattern to Rust and I can't visualize a usecase for this.
let's break this properly for OP and you.
remove `as` and go backwards, you get
R::Residual::TryType
Residual<[R::Output; N]>
Try<Output = [R::Output; N], Residual = Self>

let's call `R::Output` `U, the return type is basically one of:
Option<[U; N]>
Result<[U; N], E>

we don't know what `Self` or `T` is. if it's `[T; N]` or something similar to that, or a trait for array-like types, this would be similar to
iter
.map(|T| -> Result<T>)
.collect::<Result<Vec<T>>>()

so no, this is neither an "anti-pattern", nor hard to imagine a use-case for. you stop mapping at the first error or None and return that failed state. you can even have the previous succeeding results as a part of the error value, which is also a known pattern.
you could also not fail early if you care about partial results, but that shouldn't be called `try_map`, or arguably use the `Try` types directly as a return value.

>>105993095 (OP)
Wasn't Rust supposed to be more readable than C++

>>105993342
i'd love a non-tranny rust dialect designed by people with sense and conserving all of its advantages.

>>105994312 (Me)
i meant
iter
.map(|T| -> Result<U>)
.collect::<Result<Vec<U>>>()

>>105993095 (OP)
rust fags be like "this code is so much simpler than C++"
>>105993350
c/c++/java/c#
what are you a retard or something?

>>105993113
good morning sir

>>105993095 (OP)
thats just bad code, can do that in any language

>>105993095 (OP)
Type system wankery like this belongs, if it belongs at all, in libraries. No one writing application code should be writing retarded shit like this. C++ has same problem.

PHP looks better

>>105993095 (OP)
I can read that, though I did have to look at the Try and Residual traits.
The confusing thing here is the fact that there is both an associated type called Residual in the Try trait as well as a trait called Residual, you can wee Residual in the picture uses different colors.
The other thing is that for whatever reason it goes in a roundabout way in return: R to Try, residual of that, cast as residual value from a Try with an output of an array, cast to said try

>>105993253
Thanks, ChatGPT.

>>105993095 (OP)
What's the problem? It's just types. Or is the N throwing you off?

One picture just made me realize why g hates this language

>>105994312
>so no, this is neither an "anti-pattern", nor hard to imagine a use-case for. you stop mapping at the first error or None and return that failed state
Good Lord, you need all that garbage just to implement such a common routine?

>>105994564
those are not "casts" for starters.

>>105994670
share with us your better Try trait design. then we can go from there.

>>105994460
This is literally just a screen shot from std lib documentation. It's not even actual code editor, just badly wrapped HTML page.

>>105994670
After writing hundreds of thousands of:
if err != nil {
return nil, err
}

you will reconsider try semantics.

>>105993095 (OP)
This could be solved if Rust just kept C++/Java syntax.

>>105994415
>c/c++/java/c#
They are all different languages, what exactly do you mean by C style syntax?

>>105993095 (OP)
much more verbose than Java

>>105995620
algol-shit

>>105993113
I have no idea what you're talking about. Claude Code one shots 1000 line modules for me on the regular. Maybe an issue once or twice with a borrow... which it fixes on check.

I don't even remember last time I had to solve a borrow puzzle, it all just kinda snaps into place now, even when I am laying out a template manually. But I've been coding rust for 2 years now, every day, so not new to it.

i'm the author of >>105994312 and >>105994935 and i waited to see if there was a single real non-jeet-level coder in /g/ that would point out that this signature would have been much nicer IF rust had ergonomic HKT's, and had them from DAY ONE.
with HKT's, there would be the higher-kinded types Result and Option (without the generic params), and you wouldn't need to go through the trait bound on the Residual trait to map from R::Output to [R::Output; N] while keeping the higher-kinded type the same.
that's where rust actually showed a limitation in this case, although not that big of a deal in the end.
but all a /g/eet tard can manage to kvetch about is "syntax bad" and some random online trannies. lol.
happy /g/eet tarding everyone. keep LLMing.

>>105993095 (OP)
What syntax would you use to write the same function signature? Bearing in mind you must specify all of the same type constraints.

>>105993113
>code readability is not problem we have LLMs,
you're retarded, son. lmao.

https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/
https://media.defense.gov/2022/Nov/10/2003112742/-1/-1/0/CSI_SOFTWARE_MEMORY_SAFETY.PDF
https://bpb-us-e1.wpmucdn.com/sites.gatech.edu/dist/a/2878/files/2022/10/OSSI-Final-Report-3.pdf
https://archive.ph/uLiWX
https://archive.ph/rESxe
https://lkml.org/lkml/2025/2/6/1292

>>105993095 (OP)
>circles with the borrow checker
assuming more and more technical debt no doubt

>>105993095 (OP)
It's called Rust for a reason.
But to really drive the point home, they should have used a merchant logo and called it Debt.

>>105993113
I feel like it's in our best interest to understand the code that AI generates, especially if most code is going to be generated.
Maybe there should even be a highly readable language (think inform7 but general purpose) that is designed specifically for generation by AI and checking by humans.

Could be simplified by defining a helper trait but its really not that bad unless you are retarded.

>>105993095 (OP)
using System;

class Program
{
static void Main()
{
Console.Write("Enter your name: ");
string name = Console.ReadLine();
Console.WriteLine($"{name} is a huge faggot!");
}
}


I like it simple.

>>105998277
>simple
>crashes with 20 nested, 300-calls deep stack traces full of reflections and BeanFactorySingletonAdapter abstractions.

C# doesn't have a built in Result type or unions but if we recreate a Result type like this:
public class Result<T, E>
{
public T Value { get; }
public E Error { get; }
public bool IsSuccess { get; }

private Result(T value)
{
Value = value;
IsSuccess = true;
}

private Result(E error)
{
Error = error;
IsSuccess = false;
}

public static Result<T, E> Ok(T value) => new Result<T, E>(value);
public static Result<T, E> Err(E error) => new Result<T, E>(error);
}


then OP's code in C# (with implementation) is just:
public static Result<U, E> Map<T, U, E>(this Result<T, E> result, Func<T, U> func)
{
return result.IsSuccess
? Result<U, E>.Ok(func(result.Value))
: Result<U, E>.Err(result.Error);
}

>>105993095 (OP)
rust is a honeypot

>>105999250
The point of Try and FromResidual traits is to enable ? semantics.
It allows you to early return from a function during a dot-chain like foo.bar()?.baz()?.bax()?;, where each of these functions can return different Ok and Error variants. Ok is just passed as is, but if any of these functions returns an Error, it shortcircuits and tries to convert this error type into function's error type variant.

Like this
use std::error::Error;
use std::io::Error as IoError;

struct Foo;
struct Bar;
struct Baz;

impl Foo {
fn foo(self) -> Result<Bar, IoError> { Ok(Bar) }
}
impl Bar {
fn bar(self) -> Result<Baz, Box<dyn Error>> { Ok(Baz) }
}
impl Baz {
fn baz(self) -> Result<u8, String> { Err("String kind of error".into()) }
}

fn main() -> Result<(), Box<dyn Error>> {
Foo.foo()?
.bar()?
.baz()?;
Ok(())
}

? operator allows you to call functions with all kinds of Result as long as their Error variant is convertible into the return's Error variant.

>>105999421
interesting. so the main purpose is to not have to break the function chain all the time because of intermediate results. in a language like C# we would just put the whole chain in a try-catch
try {
Foo.foo()
.bar()
.baz();
} catch(Exception e) {
// handle errors
}

>>106000000
wasted

>>106000000
Truth nuke

>>106000058
Angry rustroon

>>106000000
Did C# just depreciate Rust?

>>105999250
>>105999421

One could almost have limited tagged unions and pattern matching in C#, alas, _sealed_ in C# is like Java's _final_, not like Scala's _sealed_, and thus there is no exhaustiveness checking. If a type is missing in the pattern matching, it is easy to get a runtime thrown exception.


using System;

record Item(String Name, int Count) {};

interface Res<V, E> {};

record Val<V, E>(V Value) : Res<V, E>;

record Err<V, E>(E Error) : Res<V, E>;

public class Program
{
public static void Main()
{
Res<Item, String> res = new Val<Item, String>(new Item("apple", 23));

var str = res switch {

Val<Item, String>{Value: {Name: var n, Count: var c}} =>
"item " + n + " " + c,
Err<Item, String>{Error: var m} => "err " + m,
};

Console.WriteLine(str);
}
}


https://dotnetfiddle.net/

guys, rust is not that bad. stop hating....

>>105993095 (OP)
Ever looked at C++ standard library types? It's the same shit.
Nobody does this type of shit for application code.

>>106000404
other languages don't do this for application code OR library code

54. Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy.

>>106000390

>>106000000
Yeah, that's exception-based error handling. Rust is using the Monad-based error handling that Haskell uses. Different approaches for the same end goal, though the Monad approach makes it explicitly clear in the return signature that a function can error, and forces the caller to either handle the error in some way or otherwise punt it down to someone else.

Most object-oriented languages use exceptions. Monads are a more functional approach.
>>106000254
The word you are looking for is "deprecate", and the answer is "not really". One of the bigger selling points of Rust is that it's a systems language and doesn't use a garbage collector. If C# was a decent option for your use case, you probably wouldn't be looking at Rust.

Anytime I look at Rust syntax I feel like I'm looking at Assembly made by retards.

>>105994396
What isn't clear in this structure? It's not hard to understand.

>>106000909
There are drawbacks to the error handling in Rust, thiserror makes it a bit more ergonomic, anyhow sacrifices some of the advantages to improve other aspects.

>>106000390
I hate map

>>106000000
>in a language like C# we would just put the whole chain in a try-catch
Yeah, except this relies on unwinding and inheritance, both are slow. It also often obscures possible error types.
Monadic error handling is more explicit and faster. It also gives you more control.

>>106001186
>>106001041

>>105993095 (OP)
>ugly syntax
>look inside
>generics
Every single time. At some point it's just type masturbation

>>106000434
other languages are also low performance trash or involve copy and pasting the same function with edits 1000 times.

>>106000000
>exceptions, le GOOD
where in that call chain did your exception come from? checkmate, atheist and kys get stealer.

>>106002206
What are the drawbacks?

>>105993095 (OP)
In C# this is just:

>>105993625

when is the tech world going to go full circle and realize the OOP with garbage collection was a good idea after all.

>>105994935
>>105994975
Zig have built-in try, you can just return that and it will work like that

>>106000000

>>106001186
who cares if unwinding is slow if the good path is fast?

>>106004543
Because then you are limited in what can you do without losing performance. In C++, it is discouraged to use exceptions for normal control flow, bur Rust has no such restriction. Monadic error handling has also many others benefits, you can nest Results and Options, you can easily store the result and handle it later, you can catch and map/handle errors within a dot-chain, etc. The only good thing about exceptions is that they are implicit, but implicitness is a bad thing in itself.

>>105993095 (OP)
I can never get over how rust just looks like some retard tryhards version of bad typescript

>>105993342
C++ unique_ptr with -Werror=use-after-move

and Rustranny lang can go and fuck itself.

>>106004690
>version of bad typescript
typescript is useful and help full at least .

>>106002399
C, Zig and Odin do not have this problem and are as fast as Rust.

>>106002464
https://github.com/rust-lang/rfcs/issues/294#issuecomment-2261576929
>Positional selection does very little to help us solve the primary ergonomics problems in Rust - most notably, error handling being atrocious.

https://users.rust-lang.org/t/errors-in-rust-can-now-be-handled-more-ergonomically-cleanly-and-simply-introducing-a-new-error-crate/51527

https://felix-knorr.net/posts/2025-06-29-rust-error-handling.html
>Defining an extra error enum for every function and all the conversions between them is extremely tedious. And so everyone and their mother is building big error types. Well, not Everyone. A small handful of indomitable nerds still holds out against the standard.

>>106004642
Implicitness isn't a bad thing. Rust would be a far better language if lifetimes were implicit. And given how much work the Rust devs have put into making the compiler better at inferring lifetimes, it seems they agree. If you disagree explain why the Rust devs thinks it's a good idea to waste a bunch of man hours implementing something that is bad.

>>106004742
>If you disagree explain why the Rust devs thinks it's a good idea to waste a bunch of man hours implementing something that is bad.
ezpz
theyre retarded (nta)

>>106004742
>Rust would be a far better language if lifetimes were implicit
They are. It's only when compiler is unable to deduce them you have to write them explicitly. I use references all the time but only rarely have to write lifetimes explicitly.

>>106004742
be honest, Rust is like forcing everybody to talk esperanto, even if the idea behind is good it looks and sounds retarded.

>>106004775
The original argument was implicitness is bad and that Rust removes implicitness. Rust (or its devs at least) obviously does not think implicitness is bad because they put in a lot of work to hide lifetimes, which is a good thing because explicit lifetimes are horrible to work with.

>>106004738
So, what are the drawbacks?
You just posted two quotes of people saying they just don't like it.

>Defining an extra error enum for every function and all the conversions between them is extremely tedious.
You don't have to do it. You can use some universal error type for everything or you can define one error type for all your crate. You can choose how you deal with errors.

>>106004788
How is this different from using a static analyzer in any other language?

>>106004799
>You can choose how you deal with errors.
What if I just want to make the errors someone else's problem? What can I do then?

>>106004789
>The original argument was implicitness is bad and that Rust removes implicitness. Rust (or its devs at least) obviously does not think implicitness is bad because they put in a lot of work to hide lifetimes, which is a good thing because explicit lifetimes are horrible to work with.
Deduction is not the same thing as obscuring. The problem with exceptions being implicit is that they obscure what kind of errors could be thrown from that function. Lifetime deduction does not obscure that information, it just means that the lifetime can be easily deduced by looking at the function signature.
This is not the same kind of implicitness.

>>106004810
>What if I just want to make the errors someone else's problem? What can I do then?
You use Result<T, Box<dyn Error>>

>>106000376
>TypeScript has tagged union but not pattern matching
>C# has pattern matching but no tagged union.
What is Microsoft thinking?

>>106004799
https://reddit.com/r/rust/comments/1lnbr0g/on_error_handling_in_rust/

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

Hi Triggcrab.

>>106004932
>random reddit and orange reddit link
So, what are the drawbacks?

>>106004853
TypeScript does at least have flow-sensitive typing to help it.

>>106004946
Why so triggered, Triggcrab? That time of month?

>>106004973
Not an answer.

>>106004977
That fits your posts, not mine, Triggcrab. So why are you so triggered?

>>105994912
Yeah yeah bitch i know and you know what I meant

>>106000994
Then you have no fucking clue what assembly is

>>106004789
Strong enforcement of local scoping, explicit reference passing, and a reference counter makes lifetime determination really obvious, with basically the same runtime behavior. In fact, you can take the reference semantics out, scope the lifetime with a pointer that lives statically on the stack, and treat it as a value by default. Bam, memory semantics not even necessary. And then you have Nim, which is a much better language for actually accomplishing things, with all the performance to boot.

>>106005399
>In fact, you can take the reference semantics out, scope the lifetime with a pointer that lives statically on the stack, and treat it as a value by default.
Rust references are just non-zero, properly aligned pointers with a lifetime. They are not a special thing like in C++.

>>106004853
I have a suspicion that C# might be able to cover a lot of _ground_ and support a lot of functionality, so to say, with relatively very little effort, just by supporting a new keyword that works like Scala's _sealed_, and then make _switch_ exhaustive on that.

>>106001012
it's just conventions for the simple-minded (99% of /g/eets).
T -> U (map)
T -> SomeType<T> (wrap)

just didn't want the simple minded to mistake maps for wraps.
>>106004363
express how i zig you can map a [T; N], where the mapper is T -> TryType<U>, where TryType<U> is some fallible type (generic), and where the success value is mapped from T -> U, and the return value of the whole operation is TryType<[U; N]>.
[T; N] could also be a generic ArrayLike<T, N>, but let's keep things simple for you.
from what i hear, you don't even have error contexts you can move up the call stack in zig, as in, there is no non-trivial E value in Result<T, E> you can use/map/... lmao
----
no comment on the c# tard /g/eet who did a non-generic map (not try_map) on a non-sum type Result, among other retardations.
but as i already established in >>105996570, there are no non-jeet-level coders in /g/ that could possibly point out where rust's type system showed a little bit of weakness here.

>>106005691
>relatively very little
good morning sir

>>106005722
Good morning sir.

Please rate >>106000376 sir. I am not C# programmer sir.

>>106005931
>>relatively very little
>good morning sir
What is the grammatical issue?
And how would you express the following otherwise?
>relative to how much effort that features and functionality can take to implement and add for this kind of case, it would take a very limited amount of effort

>>106006417
>What is the grammatical issue?
it's a semantical issue
>And how would you express the following otherwise?
the following isn't proper english either

>>106005722
>rust's type system
https://github.com/Speykious/cve-rs

https://github.com/rust-lang/rust/issues/132064#issuecomment-2461802228
>Triage notes (AFAIUI): #132625 is merged, but the compile time is not fully clawed back as #132625 is a compromise between (full) soundness and performance in favor of a full revert (full revert would bring back more soundness problems AFAICT)
>
>Chiming in -- at Oxide, in our largest repository, this appears to have made many operations much slower. For example, cargo check is twice as slow:
>1.81: 3m 37s
>1.82: 6m 51s

>>106006558
soundness issues are bugs and are intended to be fixed

meanwhile Cjeets call everything undefined behavior and debate which undefined behavior is acceptable under which tuple of (host, target, libc, compiler)

>>106006630
when are you going to fix your mental soundness issues?

>>106006558
this is not a problem with the type system but implicit lifetimes

>>106006630
Now you're just arguing semitics. If tomorrow the C Committee announced that all undefined behaviors were now labeled as soundness issues and were intended to be fixed, pinky promise, would that make C a memory safe languge?

>>106006668
once you stop mistakenly casting your identity to a woman

>>106006697
Can you explain what that means? I never had to do any casting in my entire programming career, sounds like something that would have an usecase only in a tranny language like rust.

>>106006743
>the coping has begun

>>106006748
keep coping I guess

Your honor, I rest my case.

>>106006872
lmao

>>106006872
>>106006895
>cnile discovers generated code

>>106006872
I hope Rust results in a rebellion against type insanity.

>>106006872
>pre-"const generics"
remove that from your tard arsenal. it's not applicable anymore.

>>106006872
meh, who cares
rust is not meant to be the endgame, it's an intermediate step to better programming languages
in a few decades we'll be writing software in languages saner than rust and safer than c c++ c# python etc.

>>106006949
>I hope the bar lowers so I can stop being inferior

>>106006529
>english
Good morning, sir.

>>106006630
>soundness issues are bugs and are intended to be fixed
But some of these issues have been open for years. And Polonius, meant to fix some of them, is also not ready, despite years of work. One Rust developer even claimed a few months ago that Polonius may take 5000x longer to run than the currently solver.

>>106006679
Yet several lifetime sections are listed under https://doc.rust-lang.org/reference/type-system.html .

Triggcrab, is that you?

>>106006630
>>106006685
Monologue?

>semitics
Do you mean "semantics"?

>>106007342
NTA but not all lifetimes can be implicit.

>>106007351
Triggcrab, do not lie, and your argument is trash, try again.

https://counterexamples.org/nearly-universal.html

>>105993342
Rust is C style syntax.

>>105993350
Forcing Rust to look like C/C++ instead of the ML family language it should be.

>>105996318
>algol-shit
Algol is the opposite of C-style, like begin/end instead of {} and keywords instead of !@#$%^&*. Pascal and Ada look more like Algol.

>>106007342
Whenever lifetimes are listed in reference doesn't change anything he said.
What point are you even trying to make?

>effort post about Windows Server
>get a warning
>retarded faggot shits up board endlessly with out of context opinions from literal reddit and non-issues
>is still posting

really makes you think.

>>106004360
>when is the tech world going to go full circle and realize the OOP with garbage collection was a good idea after all.
The tech world already did. Only C/C++ shills didn't. Simula 67 was OOP with garbage collection, so are Smalltalk, Common Lisp, Java, JavaScript, Python, Eiffel, C#, VB.net, and a lot of other languages, but C/C++ people hate admitting that other people were right.

>>106008393
GC doesn't save you from everything Rust does, thoughbeit.
that's what makes Rust actually revolutionary.

>>106008264
Triggcrab, you aren't fooling anyone. Why are you so dishonest and triggered?

>>106008598
What are you talking about?

>>106008387
It's funny how it's always C programmers who have this kind of schizos.
What do Rust programmers have? Bruce who keeps making fun of C++ in rather clever way? You never see this kind of deranged posts from Rust programmers.
I wonder what's the reason behind this.

>>106008630
Triggcrab, take your pills already.

>>106008644
>I wonder what's the reason behind this.
bad jannies. that's it.

>>106008676
Jannies are only enabling this behavior, but I doubt they are selective about languages.
What I am wondering is why does C produces schizos and retards. Like, how is 106008654 this guy even real lmao
>people discuss type system stuff
>posts random unrelated links
>gets corrected
>*autistic screeching*
I never seen any Rust developer do this. I probably never seen any developer do this except maybe HTMX shills. There must be something with C that attracts this kind of retards.

>>106008644
You mean the Rust community.

Jeremy Bicha.
>SEX BAT BY JUVEN/VCTM UNDER 12; F.S. 794.011(2) (PRINCIPAL - 2 COUNTS)
Rust developer.
PPA for Rust.
https://launchpad.net/~jbicha/+archive/ubuntu/rust

Hector Martin.
Insisting that Asahi Lina is not his alter ego.
https://archive.ph/uLiWX
https://archive.ph/rESxe
https://lkml.org/lkml/2025/2/6/1292

https://aturon.github.io/tech/2019/06/25/back-in-the-saddle/

https://fasterthanli.me/articles/state-of-the-fasterthanlime-2024
https://fasterthanli.me/articles/that-health-is-mental

Oh, look, here is doing literally the same thing again lmao

>>106008644
>>106008676
>>106008721
Triggcrab, please cease your schizophrenic monologue, deferring your schizophrenia to others is dishonest.

>>106008736
Yes, Triggcrab definitely is a complete mess.

>>106008721
>There must be something with C that attracts this kind of retards.
it stands in opposition to politics in programming
so defacto it stands against lgbt messaging too

i guess youre victims of your own success, kek

>>106008755
Triggcrab, cease monologuing already, stop spewing your retarded schizophrenia all over the thread.

>>106008774
im not that faggot, doebeiterald (should i say)

>>106008755
>opposition to politics in programming
C was used for politics in programming pretty much since GNU. Whole coreutils is just a rewrite of unix tools in order to change the license and push RMS' agenda.

>>106008779
See >>106008774 .

>>106008755
>it stands in opposition to politics in programming
>so defacto it stands against lgbt messaging too
>i guess youre victims of your own success, kek
But I don't use C? I am only asking why does C attracts this kind of posters. I really do not see how does C being "opposition to politics" attracts literal schizos and retards, like this guy above.

Unless you are trying to imply that everyone who doesn't support LGBT and pushing politics into technology is a schizo. But I don't see how would that make any sense.

>>106008823
Triggcrab, the only schizo and retard around here is (You). Why so insistent on monologuing with your schizophrenia?
Also you're talking about the Rust community, not any "C community" >>106008724

>>106008721
>What I am wondering is why does C produces schizos and retards. Like, how is 106008654 this guy even real lmao
there is always going to be some obsessive retards with clear mental illness with virtually anything imaginable. unfortunately C attracts the kind of retards who can also post on the internet.
It's ultimately a JANNY problem at the end of the day. the final solution to the schizo question always devolves into some authoritarian mod regime to clean up low quality trash. /g/ is probably one of the worst moderated boards ironically. I think even /pol/ and /v/ are better moderated for their rulesets.

>>106008823
>I am only asking why does C attracts this kind of posters.
and i answered
its because of the assumption that the c community is anti lgbt
when in actuality its anti politics in general

and rust is associated with lgbt because of your own branding
and so c attracts anti lgbt people ¯\_(ツ)_/¯

>>106008918
Well, on /jp/ we have one or two schizos who keep reposting twitter screencaps, aI porn and literal fucking CP and sometimes it stays for hours and shitposts stay forever.
Yet they do not want to accept janny applications. When confronted on IRC it's just "muh use reporting system and fuck off".
So much for this site's moderation. I wish they at least experimented with some more community self-moderation tools like they tried on futaba.

>>106008957
Not everyone who doesn't like LGBT is a schizo. Majority of posters on /g/ do not like LGBT, including many Rust developers and developers from other languages.
Yet you only see C programmers act like this.

>when in actuality its anti politics in general
C is not really anti politics. Like >>106008799 said, GNU is all about politics.

>>106008918
>>106008957
>>106008982
Triggcrab, the only schizo and retard around here is (You). Why so insistent on monologuing with your schizophrenia?
Also you're talking about the Rust community, not any "C community" >>106008724

>>106008982
>Not everyone who doesn't like LGBT is a schizo.
no, i didnt imply c-ultists are schizos, kek
nobody fukken likes LGBT becuase theyre objectively detrimental to society

and gnu is not C
you can easily recognize a c-ultist by the fact that were all about the craft
fuck gnus politics in the ear whatever they might be
tell me about memory layouts and how theyre accessed, i wanna see some ones and zeroes

>>106009300
>>106009003

>>106009312
>senpai notice me
i did
you can fuck off now lmao

>>105993367
I wonder what the signature would look like in TypeScript
Probably also a mess, but not quite as bad

>>106009300
>i didnt imply c-ultists are schizos
You did.
I asked:
>why does C attracts this kind of posters (schizos)
And you said:
>its because of the assumption that the c community is anti lgbt

>>105994340
I THINK Swift is shaping up to be that language

>>106008823
Because C shills are mostly Russian, Indian, and African criminals who want C because it helps them hack and scam people. They don't actually know C or how to use it to write software, just how to exploit bugs.

>>106009338
how does it make c-ultists schizos?
theres nuance to the post
a negative space type of nuance, based on the properties of the english language

focus on what each of these words mean
nothing more nothing less

>>106009356
>Because C shills are mostly Russian, Indian, and African criminals who want C because it helps them hack and scam people. They don't actually know C or how to use it to write software, just how to exploit bugs.
>mfw

>>106009359
>how does it make c-ultists schizos?
The fact that C attracts schizos is self evident based on this thread.
All I am doing is asking for the explanation of this phenomenon.

>>106009383
its *attracts* schizos != is a community of schizos
also being virulently anti lgbt is not a schizo thing to do.
yes theres nocoders who larp as c programmers to take a political stance
gosh that was verbose no wonder you need special needs languages

>>106009405
>its *attracts* schizos != is a community of schizos
I never implied otherwise.

>The fact that C attracts schizos is self evident based on this thread.
All I am doing is asking for the explanation of this phenomenon.

>>106009321
>>106009338
>>106009356
>>106009359
Fuck off, retarded, schizophrenic Rustacean. Monologue somewhere else. Also see >>106008724 .

>>106009372
>>106009383
>>106009405
>>106009421
Fuck off, Triggcrab.

>>106009421
i already told you it
if anything C is laisser faire anarchist
and since lgbt is a form of order, we dont like it
other people who dont like it too then use C as a banner
i mean
its a free country...
lgbtourists do the same with rust
and if some of the nocoders end up programming because of that, im all for it

>>106009405
>yes theres nocoders who larp as c programmers to take a political stance
You're one of them, Russkie.

>>106009436
Majority of posters on /g/ do not like LGBT, including many Rust developers and developers from other languages.
Yet you only see C programmers act like this.

That's why I am asking.
Why does C attract them?

>>106009421
i mean
>c is freedom
>attracts a bunch of anarchists and iconoclasts
>pikachuface.jaypeg

>>106009450
>c is freedom
What does that mean?

>>106009436
>>106009445
>>106009447
>>106009450
This is just spam at this point, Triggcrab. How did you get this triggered? Lack of technical achievements? Is your last name Klabnik?

>>106009447
>>106009436
ask chat gpt

>>106009461
no redtape whatsoever
wanna make your code a self modyfing mystery box?
go ahead, you just change the properties of a cache page
you wanna create a novel type?
whatever.
but yeah dont shoot yourself in the foot like a retard
i mean freedom. you do whatever you want with it including retarded shit

>>105993095 (OP)
>want code to be human readable
If you want code to be human readable, go learn COBOL.

If you actually want to get shit done, C.

>>106009489
cmon
c is human readable if one puts a modicum of effort into it

>>106009486
>>106009426

>>106009486
You can do this in pretty much every language.
You are not making any sense, you sound like the schizo.
Which nicely ties with my original question.

What did attracted you to C?
Was this just an obsession with freedom and the fact that you were unaware you can do the same things in other languages?

>>106009517
>senpai notice me
i did.
post code for a change

>>106009461
>What does that mean?
If you write your software in C, hackers have the freedom to take over your computer.

>>106009526
>>106009533
dont count on me to dress a list lmao
and no
theres only a couple languages where you can write self modifying *compiled code
self modifying scripting languages need not apply (too damn slow to be practical outside hacking)

>>106009533
Retarded, incompetent, schizophrenic Triggcrab, you haven't fucked off. Fuck off. Also see >>106008724

>>106009486
>wanna make your code a self modyfing mystery box?
>go ahead, you just change the properties of a cache page
>you wanna create a novel type?
C doesn't allow any of that. You're confusing C with assembly or Lisp. Most languages make those things much easier than C.

>>106009557
>>106009561

>>106009557
>theres only a couple languages where you can write self modifying *compiled code
So it really was just lack of general knowledge.
It makes sense considering C is often taught as the first language. Many of these schizos probably only know very little about other languages and hence think C is somehow special in this regard.

Thanks for answering.

>>106009526
>What did attracted you to C?
the lack of red tape and the perfect dose of abstraction for me
struct s_str
{
size_t size;
char text[];
};
#define STRINGIFY(target) (t_str *)(&(const struct { size_t size; char text[sizeof(target) + 7]; }){ sizeof(target) - 1, target "\0\0\0\0\0\0\0"})

>>106009573
>>106009579
Why haven't you fucked off, schizophrenic Triggcrab? Too bothered and triggered by your own incompetence?

Does this trigger the schizophrenic rustacean Triggcrab?

The Rust community.

Jeremy Bicha.
>SEX BAT BY JUVEN/VCTM UNDER 12; F.S. 794.011(2) (PRINCIPAL - 2 COUNTS)
Rust developer.
PPA for Rust.
https://launchpad.net/~jbicha/+archive/ubuntu/rust

Hector Martin.
Insisting that Asahi Lina is not his alter ego.
https://archive.ph/uLiWX
https://archive.ph/rESxe
https://lkml.org/lkml/2025/2/6/1292

https://aturon.github.io/tech/2019/06/25/back-in-the-saddle/

https://fasterthanli.me/articles/state-of-the-fasterthanlime-2024
https://fasterthanli.me/articles/that-health-is-mental

What a community.

>>106009579
>So it really was just lack of general knowledge.
then enlighten me
which languages do that

rust
sepples
asm
evendoe its not exactly compiled?

you 100% could hack python into doing that since you can wrap c
but its not exactly paiton then
java is jit
what else?

>>106009593
>>106009617

What is it that causes a Rustacean like you to have so severe mental health issues?

>>106009648
>

>>106009617
>which languages do that
Pretty much every language that let you access internals and raw memory. Even Python, C# and Java have things for that.

>>106009700
python is not compiled.
you can make it compiled but thats an external tool
java is JIT
what is it that you said about general culture again?

didnt know you can do that with c # doe.
jeetlang anyways.

and thats a pretty short list compared to all languages there is

>>106009699
>>106009700
>1 second apart
>>106009725

Fucking fix yourself and fuck off, Triggcrab. Try out antiparasitic medication or whatever.

>>106009337
You can't express something like that in typescript. Even if interfaces somehow resemble traits, they have no associated types or methods. Even if you use abstract classes to somehow imitate that, static methods can't even reference class level generic arguments.
This code is really not something you would write in a duck-typed, inheritance based type system.

>>106009763
>
(arroe)

>>106009725
No idea what you are even trying to say at this point, but I have answered all your questions so I don't see any point to continue this conversation.

>>106009783
Didn't even click.
Fuck off, triggered, incompetent Triggcrab.

>>106009787
youre a retard
you shouldnt have started this conversation to begin with
youre clearly fucking outclassed
to the extent of repeating one of the langs i explicitly cited in my post

you have severe mental retardation, anon
you should take that into account

>>106009787
>>106009802
See >>106009789 .

>>105993095 (OP)
In some ways not that different from Scala or Haskell or C++.

what kind of mental illness compels someone to do this?

>>106009778
Typescript has a surprisingly advanced/complex type system in some ways, though I don't know much about its type system or its actual characteristics, and how it fits into contemporary type theories. It might be the case that you are right.

The type signature involves Try, and Try has several types inside its type description, Output and Residual. Are those type members?
https://doc.rust-lang.org/std/ops/trait.Try.html

pub trait Try: FromResidual {
type Output;
type Residual;

// Required methods
fn from_output(output: Self::Output) -> Self;
fn branch(self) -> ControlFlow<Self::Residual, Self::Output>;
}


Rust and Scala might both have type members (maybe "associated types" in Rust), and Typescript does not look like it supports that.
https://github.com/microsoft/TypeScript/issues/42249

>>106009977
Hello Triggcrab, how about fucking off instead of spewing your actual mental illness here? And try to get some technical achievements to your name, if you are able to.

>>106008724
https://www.spinics.net/lists/kernel/msg4888830.html

https://lore.kernel.org/lkml/c1bf62a2-e381-c796-2219-17a578987a76@marcan.st/T/

>>106009977
using the sharty, an altchan specializing in mental illness

>>106010021
>>106009998

>>106009977
It's trivial to put into filters so I am not complaining.

>>106010021
I don't even think sharty is this bad.

>>106010135
nah
thats typical sharty behaviour
its in their culture

>>106009982
>Typescript has a surprisingly advanced/complex type system in some ways
Does it? I was talking with a coworker doing webshit and from what he said and from what I googled around it has no built-in tagged union equivalent, the closest it has is storing different variants nested as a member and checking if they're valid or having an explicit determinant member and switchibg on a fucking string

>>106010135
what you saw here is even specific to shartyposters
i wont tell you what it is exactly or the other dweeb will learn how to better cover his tracks

at its core, the whole philosophy is to bait into shitposting

>>106010166
NTA, but yes, typescript has one of the most sophisticated type systems out there. You can do some really crazy stuff with it. Few months ago someone ported DOOM to the TS type system alone.
However, it is fundamentally different from Rust or Haskell because it is duck typed instead of nominally typed.

>no built-in tagged union equivalent
interface Ok<T> {
tag: "ok",
value: T,
}

interface Err<E> {
tag: "err",
value: E,
}

type Result<T, E> = Ok<T> | Err<E>;

>having an explicit determinant member
That's what "tagged" part means.

>>106010007
Hector Martin's behavior in terms of Asahi Lina is so confusing. On one hand, he wants to have a separate pseudonym. On the other hand, he intertwined his own identity with Asahi Lina ridiculously much, mingling them in the same projects even, without that much care. Denying it when it is this obvious, is in my opinion way worse than the pseudonym itself. And while the pseudonym is strange, I don't know if anyone would care if it was public information that Hector Martin is Asahi Lina. Did he catfish anyone for donations or something?
But what is a million times worse than any of that is Hector Martin doing social media brigading and making lists of people.

>>106010156
Nobody on the sharty is like this geg, this is textbox insecure 4troon who takes things too seriously behavior

>>106010037
>>106010135
>>106010156
>>106010179
>>106010236
Hello Triggcrab, how about fucking off instead of spewing your actual mental illness here? And try to get some technical achievements to your name, if you are able to.

>>106010236
nono
whats hidden is cados ass. you know how things went from there
turbo repetitive behaviour
new levels of autism never thought possible bc 4 keks won in the end lamao

i posted on the sharty long enough to get to really know you
i posted way before 4keks refugees showed up too

>>106010226
It's just typical vtuber persona stuff. The identity of Asahi is not a secret. You can think of this as branding, which it essentially is for his Linux distro. It's like when same corporate developer that can contribute shit both as nvidia as its employee and as foss individual in his free time. Whenever that makes sense for a "FOSS project brand" to contribute is left to interpretation but who cares really.
>But what is a million times worse than any of that is Hector Martin doing social media brigading and making lists of people.
Which was in response to Hellwig's equally unprofessional behavior.
All this drama could be avoided if Linus did his part as a leader and step up to resolve the conflict. But instead he just watched it unfold from side until both of them get upset and left Linux.

>>106010166
>switchibg on a fucking string
String literals can be part of the type system in Typescript, including for checking exhaustiveness.

https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types

let x: "hello" = "hello";
// OK
x = "hello";
// ...
x = "howdy";
// Compile-time error: Type '"howdy"' is not assignable to type '"hello"'


They also have unions and intersections of types IIRC, possibly the same as Scala.
Like

https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types
https://www.typescriptlang.org/docs/handbook/2/objects.html#intersection-types

https://docs.scala-lang.org/scala3/reference/new-types/union-types.html
https://docs.scala-lang.org/scala3/reference/new-types/intersection-types.html

>>106010208
>>having an explicit determinant member
>That's what "tagged" part means
Well no, having a determinant makes a tagged union. Not explicit or not member (or rather - accessible member). Discriminant in rust is not even a member, it's completely inaccessible, as it may not even exist for some types. The discriminant in std::variant is private.
In your code tag is just a member. You need to remember to check it before accessing other members yourself. This is a worse solution than enforcing access to variant types via cobtrol from (pattern matching, rusts' if statements), or via a visitor (Option::map or std::visit). Or even than exceptions because if in your case T and E both have a member foo, if you access result.value.foo without checking tag first it will work, std::get for std::variant would prevent that though. Can you overwrite tag to an invalid value?
Not shitting on ts or whatever, I'm sure it's not easy adding types back into a prototype language. But to me the | is just making unions to which you can add a tag yourself. That's why I asked for a built-in solution. Something like that would be less error prone and more performant imo

>>106010308
Kindly kill yourself, negative-worth, wretched piece of shit.

>>106010288
>>106010267

>>106010394
>You need to remember to check it before accessing other members yourself.
IIRC, Typescript disallows you from doing that at compile-time unless you check the tag. Also by using flow-sensitive typing.

>>106010363
Okay that makes it much better. Still I would like an integrated solution that would autogenerate the discriminant and a way to enforce checking it in control flow.

>>106010424
Even if both variants have a member "value"? If it does then the only complaint remaining is using a string, but I guess any performance penalty would come from how the js engine executes it, if it has some sort of table for literalls so two literalls would boild down to pointer compare not checking hashes or content byte by byte

>>106010363
NTA, but one of my favorite features of typescript is type level string templates.
export type DeepKeys<T, P extends string = ""> =
T extends null | string | number
? P
: P |
{
[K in Exclude<keyof T, symbol>]: DeepKeys<T[K], P extends "" ? `${K}` : `${P}.${K}`>
}[Exclude<keyof T, symbol>];

const value = {
a: 5,
b: null,
c: [{ foo: 123 }, { foo: 123 }],
d: {
kek: 123,
lel: 123,
}
}

type Keys = DeepKeys<typeof value>;

Keys is an union of "" | "a" | "b" | "c" | "d" | "c.0" | "c.0.foo" | "c.1" | "c.1.foo" | ... | "d.kek" | "d.lel"
What other language can do this lol

>>105994312
I've never seen this before, what could it be useful for? Mapping data types? Correcting data within a dataset?

>>106010464
When is this level of type masturbation you have been demonstrating over and over again ever useful in the real world? If you start doing this in any code base where you're not the sole author you're going to be chased out the building.

>>106010394
>Well no, having a determinant makes a tagged union. Not explicit or not member (or rather - accessible member).
It is an union and it has a determinant. So it's a tagged union. Even if you write it out explicitly.

>Discriminant in rust is not even a member, it's completely inaccessible
std::mem::discriminant

>You need to remember to check it before accessing other members yourself.
You can't access any fields that aren't present in every variant unless you check the determinant. In this case it will work but value will be of type T | E. If the variants had different names for fiends, you would be forbidden from accessing them unless you check the determinant.

>Can you overwrite tag to an invalid value?
Not to an invalid value but you could assign "err" to it even if value was of T type. But if you mark tag as readonly(which I should have done), it will work as expected.

>But to me the | is just making unions to which you can add a tag yourself. That's why I asked for a built-in solution.
Being able to specify your own determinant is more flexible and useful. You can use it to express more complex unions this way.

>Something like that would be less error prone and more performant imo
Types are fully evaluated during compilation. It doesn't change runtime performance in any way.

>>106010541
>When is this level of type masturbation you have been demonstrating over and over again ever useful in the real world?
This code is from actual project I done at work.
We have a large, nested object representing state of a very complex, large form. We wanted form components to be able to modify anything within that form by dispatching a simple update action like { type: ActionType.Update, path: "some.path.to.value", value: T }. These actions can come from all sorts of places and we want to make sure that the paths and value types are correct. That's when DeepKeys<T> type comes in handy, along with DeepIndex<T, Path> type that can be used to convert such path into concrete type from that state object for value field.

>>105993095 (OP)
Is this what fucking trannies do all day?

>>105993253
Do or do not, there is no try.

>>106010579
What's wrong with a good ol constant or enum instead of cramming as much complexity into your type system and basically making a dsl every project?.

>>105993095 (OP)
i can read it
no idea what it does though

>>106010579
>This code is from actual project I done at work.
wrong if you use a type system you dont have a job

>>106010602
Enum for what? To uniquely identify every one of like hundred different nested fields? And that not counting intermediate arrays. And even if you do that, you would then need a fuck large switch case for every field, each having complex spreading to ensure immutability of state like { ...state, field: { ...state.field, foo: { ...state.field.foo, value: value } } }
That's a lot of work just to not define this on type level and use simple recursive functions to query and update the state.

>>106010542
>It is an union and it has a determinant. So it's a tagged union.
I agree, that's why I said
>having a determinant makes a tagged union
I disagreed with the
>having an explicit determinant member
explicit and member part here.
Does having a blue car make you a car owner? Yea, but being a car owner is not having a blue car, it's having a car. Whatever, we agree.
>std::mem::discriminant
That's not member access, that's returning an opaque type that you can only compare for equivalency, print, has, or pass around. As I said the actual discriminant is inaccessible because it may not "exist".

>Being able to specify your own determinant is more flexible and useful
But less ergonomic. Having an unrestricted do-whatever language like js is is more flexible than constraining yourself with types by usibg typescript. Flexibility is not universally good.
>Types are fully evaluated during compilation. It doesn't change runtime performance in any way.
But the discriminated variant access is not, I assume switching on a number is faster than switching on a string, but with no built-in solution types more ergonomic to the programmer. Also it's an interpreted language usually sent over the internet so the length of the code itself also has an impact. So
>if(a.tag==="err")
is slower than
>if(a._i===1)

>>106010583
No, they also make gotards seethe on the regular
https://news.ycombinator.com/item?id=44672003

>>106010684
Determinant being explicit and accessible doesn't make the union any less tagged.

>But less ergonomic.
The difference is only that instead of putting everything inside enum declaration, you have to declare every variant outside of the enum and then combine them into one union type. Sure, it takes a little bit more code, but you get more control and, most importantly, you can use it to type JS code that uses non-integer determinants.

>But the discriminated variant access is not, I assume switching on a number is faster than switching on a string, but with no built-in solution types more ergonomic to the programmer. Also it's an interpreted language usually sent over the internet so the length of the code itself also has an impact. So
>>if(a.tag==="err")
>is slower than
>>if(a._i===1)
Then use numeric discriminat.
interface Ok<T> {
tag: 0,
value: T,
}

interface Err<E> {
tag: "err",
value: E,
}

type Result<T, E> = Ok<T> | Err<E>;

Or even
enum ResultDeterminant {
Ok,
Err,
}

interface Ok<T> {
tag: ResultDeterminant.Ok,
value: T,
}

interface Err<E> {
tag: ResultDeterminant.Err,
value: E,
}

type Result<T, E> = Ok<T> | Err<E>;

>>106010734
>tag: "err",
I meant tag: 1, but you get the idea.

>>105993095 (OP)
At the very least if the code isn't meant to be read it should be elided by default.

>>106010733
I have still yet to see a real world rust program.

>>106010931
Your post has been processed by some in order to end up here.

>>106010602
you realize this is for Javascript right?
Typescript takes a stance against including any features that needs to be "compiled" into js. that's why ts enums are also generally considered bad.

>>106010464
ok... that's kinda based. I will steal this.

>>106010733
I am a Rust user myself and this post is garbage. In the practical side of the argument, he's pretending that thread safety bugs can lead to exploits like normal temporal memory safety bugs, but they absolutely don't. They lead to crashes, sure, but so does bounds checking.
And from the theoretical side of "muh program cannot break the language", Rust programs can absolutely break the language, because they can use unsafe or call into badly written unsafe functions.
I wish some new language came out so I wouldn't have to associate myself with these gay boomers.

>>106011758
Data races can lead to memory corruption and this can result in hard to debug errors or exploits. Data races do not always result in a guaranteed unwinding like bounds checking. Even in that example the program causes segmentation fault instead of catching the error and panicking.

>And from the theoretical side of "muh program cannot break the language", Rust programs can absolutely break the language, because they can use unsafe or call into badly written unsafe functions.
I think you are missing the point. That post is just trying to show that you can't guarantee memory safety without ensuring thread safety. Go is said to be memory safe language, but badly written multi threaded code can cause these problems. Unsafe Rust makes no such guarantee. On the other hand, safe Rust is designed to mitigate both of these issues.

>>106011856
Data races *can* theoretically be exploited, but in practice it doesn't really happen. There are countless thousands of known exploits due to regular memory safety, but you'd be hard pressed to find just a handful of ones due to thread safety. Still, the article is arguing that they should just be considered as one category. There is clearly no *practical* justification for claim like this.
It's true that data races give you a segfault, or very rarely a memory corruption, instead of a nice unwind, but this is a problem of a completely different scale, it's just dishonest to use this as an excuse to try to convince people that you can't have memory safety without thread safety. If there are two classes of bugs, one which is responsible for 70% of software exploits, and another which occasionally fucks up your backtraces, and you try to convince people that they really should be counted as one and you can't say you've fixed anything unless you fixed just the first one, you're a stupid faggot and you should get your head out of the semantic argument gutter.

It's also pretty gay that he defines memory safety as "can't get UB" and calls Rust safe without even mentioning safe or unsafe Rust, but whatever, that point has been talked to death, I guess we know what he meant.

>>106011758
people have demo'd exploits on tearing go fat pointers before thoughbeit.

>>106010959
prove it or never say this again

>>106012675
NTA but CloudFlare uses Rust in their backend and it's called Pingora. Also Chrome recently ditched harfbuzz and uses a rust based font engine.

>>106012770
that proves nothing you failed so you never get to shill rust again go back to the ruby coalmines

>>106012770
So this is why cloudflare is so slow?

>>106012817
Sounds a bit like a cope to me bro
>>106012828
Nah it's probably just your internet

>>106012828
>Why is a global proxy that takes facial abuse from TiBs of spam slow?
This is basically the modern internet in a nutshell nowadays, anon. Any comparable system will be as slow as you perceive. Keep in mind 4chan uses a lot of shitty anti features like:

WAF
Steganography resistance (reencoding your uploads)
And probably some other spyware bullshit.

It has little to do with Rust, C++ or whatever other languages are used and just unfortunate reality.

BTW my web servers in Rust can service 100k requests per second with one thread. Cope.

>>106007431
Nah you're wrong lmao

>>106012990
It was fast a decade ago.

>>106012990
>my web servers in Rust can service 100k requests
you mean 0 they dont exist

>>106012990
My bash script can also handle 100k local socket creations per second while doing absolutely nothing, nobody is impressed.

>>105997140
>you're retarded, son. lmao.

BASED.

>>106011758
>I wish some new language came out so I wouldn't have to associate myself with these gay boomers.

Finally, we found the enlightened Rustacean.

If you want fast speed and no bullshit, OCaml has existed for ages.

Rustaceans fell for the "systems programming" bullshit. Since they ignore computing history, they don't know you can also do systems programmign using a high level language and with garbage collection. Lisp machines already did it in the 1980s. Even supercomputers and mainframe computers were programmed in higher level languages.

Rust is a regression, it's like a bad clone of Haskell (which has some problems of its own), but without the garbage collector, thus the programmer needs to become the human garbage collector and be the cuck of the Borrow Checker. Yeah, i guess their only escape now is to generate Rust code using LLM to end up with code that works wrongly in increasingly shitty ways.

>>106008400
>GC doesn't save you from everything Rust does, thoughbeit.

What the fuck?

Quite the opposite, a GC allows you even more memory safety than fucking Rust where all your "borrow checked" code ultimately calls Rust libs full of unsafe {} sections.

The vector stdlib of Rust used to segfault not long ago...

>>106014780
>GC allows you even more memory safety than fucking Rust
That's not true. GC doesn't prevent memory corruption from data races. https://news.ycombinator.com/item?id=44672003

>where all your "borrow checked" code ultimately calls Rust libs full of unsafe {} sections
All your GC code also ultimately calls potentially unsafe operations. At some point you are going to interact with the hardware, you cannot escape that.

>>106010463
I suspect the performance issue is real, I do not know how easy it would be to optimize it for JS engines.

As for common fields, they can be used as is, if the type is the same or the usage is compatible with whatever the union (not tagged union, type union) has.



type A = {
kind: "a";
value: string;
dissimilar_value: number;
}

type B = {
kind: "b";
value: string;
dissimilar_value: {x: number; y: number;};
}

type TU = A | B;

const tu: TU =
false
?
{
kind: "a",
value: "some value",
dissimilar_value: 16,
}
:
{
kind: "b",
value: "other value",
dissimilar_value: {x: 3, y: 4},
};

console.log("value : " + tu.value);

// Fails to compile:
// Operator '+' cannot be applied to types 'number | { x: number; y: number; }' and 'number'.
//console.log("dissimilar_value + 5 : " + (tu.dissimilar_value + 5));

// Fails to compile:
// Property 'x' does not exist on type 'number | { x: number; y: number; }'.
// Property 'x' does not exist on type 'number'.
//console.log("dissimilar_value.x + 7 : " + (tu.dissimilar_value.x + 7));

switch (tu.kind) {

case "a": {

console.log("dissimilar_value + 5 : " + (tu.dissimilar_value + 5));

break;
}
case "b": {

console.log("dissimilar_value.x + 7 : " + (tu.dissimilar_value.x + 7));

break;
}
}

>>105993113
>code readability is not problem we have LLMs
what the fuck? that makes readability even more important

>>106010430
That is fair, but I believe the reason why Typescript does not have that, is that Typescript intentionally is only a thin layer over Javascript; it has minimal code generation and semantics of its own, the language designers try really hard to just make it compile more or less straight to Javascript. That has helped adoption, and has helped compatibility with Javascript a lot.
Typescript has also tried to adapt its type system to existing Javascript usage patterns, while having easy escape hatches. Maybe a bit too easy, developers have to do due diligence and not simply spam ": any" everywhere.

One weakness of Typescript is that a Typescript program can still have type bugs even if no escape hatches are used. Those cases are mostly rare, but the type system of Typescript is more "best effort" than a guarantee. Typescript can still have huge value in practice, but this aspect of its type checking and type system is something to be aware of.

>>106010733
Some parts of that blog are good, others less so.

I like the usage of "absence of undefined behavior", that is a clearer definition.
I agree with Go having undefined behavior.

Java is memory safe/AOUB, outside its rarely used escape hatches, but its behavior can still get very weird if its memory model is broken. Something that probably surprises most professional Java developers.

I disagree somewhat about the definition of thread safety claimed, different contexts define it differently. For instance, in some contexts, also formal contexts, "thread safety" includes absence of deadlocks, and this is not specific to the contexts of the Java community.
Rust is clearly also not memory safe/does not have absence of undefined behavior, its escape hatches are too prevalent, too often required for too many reasons, and more difficult overall and in several ways to get correct than even C and C++ https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/

>>106011758
>They lead to crashes, sure, but so does bounds checking.

Are you a Rustacean setting up a strawman?

>>106011758
>>106011856
>>106012543
>>106014741
More monologuing by Triggcrab, fuck off.

Funnily, UB can be gotten in Ocaml.
https://www.irif.fr/~scherer/research/mutable-patterns/mutable-patterns-mlworkshop2024-abstract.pdf
https://www.jdoodle.com/compile-ocaml-online

>>106014741
>If you want fast speed and no bullshit, OCaml has existed for ages.

OCaml is comparable in speed to Rust?

>>106012770
>Also Chrome recently ditched harfbuzz and uses a rust based font engine.
I thought that they are still using Harfbuzz, only that they hope to replace it with Harfrust.

>>106012995
Why so triggered, Triggcrab? Try being honest for once.

>>106014780
Yes and no, it could make sense to add borrow checking, or affine types/substructural type system, or effects, etc., to get increased checking. Ocaml has had recent research into that.
https://www.janestreet.com/tech-talks/making-ocaml-safe-for-performance-engineering/
I wonder if Go could benefit from something similar to what Ocaml is doing with thread safety.

>>106014919
But Rust requires using its escape hatches in many more cases and much more frequently than for instance Java (though Java is also typically used for different kinds of applications). And its escape hatches are overall and in several aspects significantly more difficult to get correct than even C and C++.

>>106014919
>That's not true. GC doesn't prevent memory corruption from data races.
I genuinely don't understand this. Is locking a data this hard? Do you really need the compiler to be handhold you?

>>106016541
this the real life rust code is 999$ unsa;fe

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

>>106016634
NTA, but locks are seen by some as a relatively low-level concurrency abstraction that is error-prone.

>>106016782
Don't you still use those in rust when the code need them?

>>106016859
Yes, and if you are not careful or take proper precautions, you can for instance get deadlocks.
https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html

>>106016880
Rust is practically useless for multi threaded safety noted

>>106016880
I never had a deadlock in any language, only happens to retards.

>>106017137
NTA, the entire selling point of rust is that it's retard proof

>>106014741
I disagree with about everything that you said. I use Rust because it's a real fast low-level language without a garbage collector. Memory safety (the real kind that causes 70% of CVEs, not the irrelevant data race kind) doesn't matter that much to me specifically, but it's pretty self-evident that it matters a lot globally. So I definitely count it as a positive.
OCaml is an irrelevant language with none of rust's benefits.

When I code in Rust it's basically one giant unsafe block with a bunch of static variables. It makes the language really quite nice to use.

>>106017569
Are you sure it doesn't have a GC? Everyone and their mum uses a bunch of Rc<T>/Arc<T>.
>inb4 reference counting isn't garbage collection.
Cope

>>106017477
Yes, us Indians do not use Rust because we are a superior breed of programmer in comparison to wh*teoids.

>>106017594
I don't use that crap, so I don't care.

>>105994312
What's a double colon do? What do the <> do? And the ;? And []? And what about |whatever|?

don't answer. It's garbage.

>>106017594
If you need gc you can't code.

>>106017667
[Type; N] with the semicolon means a N-sized array or T's. || is like () but for closures. Everything else has the same meaning as in C++.

>>106017477
It never advertised itself as preventing deadlocks. Only retards think Rust does it.
Same with race conditions.

>>106016541
>But Rust requires using its escape hatches in many more cases and much more frequently than for instance Java
There is nothing you can write in Java without unsafe(excluding UB) that you can't write in Rust without unsafe. Yeah, Java has unsafe too.

>And its escape hatches are overall and in several aspects significantly more difficult to get correct than even C and C++.
It's not that much more difficult. There is only handful of UB in unsafe Rust that don't exist in C/C++. And in a typical project, unsafe only takes very little % of LoC so it is harder to make mistakes overall.

>>106016634
Do you understand the concept of a guarantee. Of course it is trivial to write code without any sort of bugs or problems, at least that's what freshman /g/eniuses claim.
But here we are talking about safety, about language preventing some bugs not about difficulty of a programmer getting things right.

>>106016859
You use Mutexes and RWLocks when you have to. However rust offers alternative solutions that do not induce extra cost, like Send/Sync traits, scoped threads, etc.

>>106017594
>When I code in Rust it's basically one giant unsafe block with a bunch of static variables.
git gud

>>106017594
So C++ and GNU C is garbage collected then?

>>106017697
>Everything else has the same meaning as in C++.
What an elegant language to borrow from.

>>106017715
Neither Rust nor C++ ever meant to be elegant. They are meant to be functional first, they are not academia languages.

>>106017724
I guess you have to keep the jeets from shutting off the fuel. Personally, I just don't turn off the fuel.

>>106017715
Yes, copying too much from C++ is Rust's original sin. But it's hard to blame them, at the time there really weren't many other languages to copy from. It was just C, C++, a bunch of unserious garbage like java or python, or academic languages that the Rust creators rightly had never heard about

>>106017746
Instead of using rust, why not just write bug-free code?

>>106017814
crabs believe thats humanly impossible

aww no challenge
i actually had a direct counter attack ready for that

on a different note, im utterly surprized i wasnt taught picrel at school
i had to rediscover that idea independently

>>106014919
>interact with the hardware
*the kernel

>he thinks they all just write normal C and simply do not make mistakes
>he doesn't know that they all use tools and guidelines that make it much much more restrictive than Rust with borrow checker
>he doesn't even realize the MB Dis not even C programming but building programs from blocks and then generating C code

>>106018015
>MB Dis
*MBD

>>106018015
>he doesn't even realize the MB Dis not even C programming but building programs from blocks and then generating C code
nono, i realized that
independently rediscovered that as a concept, remember?
yesterday i was talking about this in the context of ai
->intermediary representation
im not the only one who had to rediscover the idea bc industry is barely starting to go into that direction

otherwise yeah
i write spotless, non idiomatic C
turns out youre a retard bc you physically cant
>no you
as expected from a developmental

>>106016901
Locks are popular for semi-low-level concurrency work. Just, they have to handled with a lot of care, like using various techniques for ensuring that they are used correctly. And using higher-level abstractions when applicable can be a good idea. There are typically different trade-offs.

>>106017137
Sure, if one for instance correctly uses techniques like hierarchical locking. But there can be other issues as well.
What concurrent software have you worked on?

>>106014741
>>106017569
>>106017594
Fuck off with your schizophrenic monologuing, Triggcrab.

>>106017708
>It never advertised itself as preventing deadlocks. Only retards think Rust does it.
>Same with race conditions.
https://doc.rust-lang.org/book/ch16-00-concurrency.html
Official book for Rust has a whole chapter named
>Fearless Concurrency

>>106018089
NTA, I wrote quite some concurrent programs, web servers, parallel renderers, number crunching, etc.
I guess it really depends on kind of software. I never had any deadlock because I use RAII and I never share two different resources between two threads, it's always just one Mutex/Lock. If I was writing something specific that requires multiple mutexes shared between multiple threads I might have encountered deadlock. I think I am aware of them and wouldn't fall for it, but you never know.

>>106018103
>https://doc.rust-lang.org/book/ch16-00-concurrency.html
ahahahaha
what the fuck is this, crabs?
and you expect people are gonna use this?

>how to fuck up a language beyond repair
look at rust
add more procedures and complexity rises to the square of their count

>>106018103
Literally the very next chapter:
https://doc.rust-lang.org/book/ch16-01-threads.html

>Because threads can run simultaneously, there’s no inherent guarantee about the order in which parts of your code on different threads will run. This can lead to problems, such as:
>Race conditions, in which threads are accessing data or resources in an inconsistent order
>Deadlocks, in which two threads are waiting for each other, preventing both threads from continuing
>Bugs that happen only in certain situations and are hard to reproduce and fix reliably
>Rust attempts to mitigate the negative effects of using threads, but programming in a multithreaded context still takes careful thought and requires a code structure that is different from that in programs running in a single thread.
It literally days it doesn't prevent deadlocks. Learn to read.

>>106018103
>>106018124
i never confronted myself with the complete and utter autism of the rust language
this is what happens when autism is left unchecked and directionless
fukken 0 meta-analysis skills

im legit shocked
i expected bloat but expecting something and actually seeing it irl are two different things

>>106017708
>There is nothing you can write in Java without unsafe(excluding UB) that you can't write in Rust without unsafe. Yeah, Java has unsafe too.
Completely false. Idiomatic, decently performing Java generally does not use any escape hatches, instead relying on JIT compilation for performance. Idiomatic decently performing Rust can conversely require escape hatches for performance, and Rust projects often cite performance as a reason to use the escape hatches.
Furthermore, the escape hatches are sometimes used to deal with the borrow checker regarding architecture and design.

>It's not that much more difficult. There is only handful of UB in unsafe Rust that don't exist in C/C++. And in a typical project, unsafe only takes very little % of LoC so it is harder to make mistakes overall.
You are directly spreading falsehoods here. The aliasing requirements are significantly more difficult, as you well know. Unless you are too incompetent to realize it. How much UB do you have in your codebases? When did you last run Miri, Valgrind and gdb on them? Are you able to discover all UB without using Miri, just by looking at code? Do you know about Miri's inherent shortcomings, despite how useful it is?
And the blocks using the escape hatches in Rust generally requires a lot more code than merely those blocks to be correct, to not have UB. Are you so incompetent that you are not aware of that? Or did you instead lie by omission?

im legit shocked
WHY DO YOU HAVE AN OS LIKE INTERFACE BW YOUR THREADS IN YOUR PROGRAMMING LANGUAGE?
>because of ownership
ofc bc of ownership
your fukken memelang creates problems it then has to solve
and everyone then wonders how after 18 years of development its still unfinished

total autist death now

>>106017746
>or academic languages that the Rust creators rightly had never heard about
Graydon Hoare cites lots of "academic" languages as inspiration for Rust and in his blog posts.

Troll is (You).

>>106018113
Your post is suspicious in multiple different ways.

>>106018124
>>106018132
>>106018140
And yet Rust evangelists has kept repeating "fearless concurrency". And then confused Rust newbies go ahead, burn themselves, and then asked confused questions on Rust social media places and get "actually, ..." answers.
Genuinely an example of Rust dishonesty, but one of the much less severe ones, since at least Rust evangelists are quick to admit that they are lying about "fearless concurrency", even while using euphemisms.

>>106018227
actual cult like behaviour
and the evangelists back down only because they know that resisting would only make them look even worse
because they dont stop with their evangelism after that
they know the lang is shit
but they WANT you to use it

>>106018227
not to mention the whole concept of rust is redundant when you have model based design tool
oh, but these are for the aerospace, goy
you, at your adult daycare, you will be using rust
so that whatever youre gonna build is gonna take 10x the effort
>>106017947

>>106018234
You might be sarcastic or playing along, but
https://archive.ph/uLiWX
https://archive.ph/rESxe
https://lkml.org/lkml/2025/2/6/1292
is far more indicate of "cult" behavior. Especially since the Rust community at large supported Hector Martin in his social media brigading.

>>106018205
Why?

>>106018254
>mfw no, u

>>106018253
I welcome research and advancements in programming languages, and I was initially hopeful about Rust. And Rust does have genuinely nice features, like pattern matching.
Are you Triggcrab, or just a demented troll?

>>106018254
>indicate
indicative

>>106018265
>>I welcome research and advancements in programming languages, and I was initially hopeful about Rust. And Rust does have genuinely nice features, like pattern matching.
>>Are you Triggcrab, or just a demented troll?
>talks like a demented troll
what did this anon mean by this?

>>106018260
>>106018264
Hello Triggcrab, how are you so permanently triggered? Any technical accomplishments to your name? No?

>>106018283
>t.

>>106018281
Hello Triggcrab, the only demented person or troll here is (You). Now fuck off.

>>106018290
>mental illness, the post
did you even sleep?
youre posting since something like 12 hours now

>>106018287
How Brave of you.

>>106018302
>and a seething firetranoid on top of that
you cant make this shit up
this goes into the collection

>>106018294
Who is mentally ill? Me, who is not wasting time trolling? Or you, Triggcrab, who keeps trolling repeatedly?
Try again, schizophrenic retard.

>>106018306
Guessing will not make me tell you, Triggcrab. Now fuck off and cease trolling.

>>106018161
>Completely false. Idiomatic, decently performing Java generally does not use any escape hatches, instead relying on JIT compilation for performance. Idiomatic decently performing Rust can conversely require escape hatches for performance, and Rust projects often cite performance as a reason to use the escape hatches.
These are different orders of performance, you are comparing a GC VM-based managed language to a systems programming language. Even if you have to use some Rcs and Mutexes to write whatever algorithm in safe subset of Rust, it is not going to be slower than a GC language where literally everything is a reference counted, heap allocated class instance.

>Furthermore, the escape hatches are sometimes used to deal with the borrow checker regarding architecture and design.
This only applies to some zero cost data structures.

>The aliasing requirements are significantly more difficult, as you well know.
True, but it's not all that hard to get right.

>How much UB do you have in your codebases? When did you last run Miri, Valgrind and gdb on them? Are you able to discover all UB without using Miri, just by looking at code?
I rarely write any unsafe in my projects, and if I do, it's usually very simple things like FFI or accessing some low level API.

>And the blocks using the escape hatches in Rust generally requires a lot more code than merely those blocks to be correct, to not have UB. Are you so incompetent that you are not aware of that? Or did you instead lie by omission?
Lack of UB is one of the essential properties of correct code.

>>106018227
>And yet Rust evangelists has kept repeating "fearless concurrency". And then confused Rust newbies go ahead, burn themselves, and then asked confused questions on Rust social media places and get "actually, ..." answers.
You could have said the same about Go and it's claims about memory safety, which fall short as soon as you have a data race. It's the same kind of "actually, ..." you are complaining about. Hell, I even seen multiple people on /g/ claiming that all memory problems in C++ can be solved simply by using smart pointers. Does that mean they are dishonest C++/Go evangelists? Or just misinformed newbies who can't RTFM.

>>106018355
given the circumstances id err towards the later
rust is a social issue for the lgbtgroids

>>106018355
>>106018389
>latter
err i mean former
and it doesnt mean that go and sepples cant have their evangelists either

>>106018332
>These are different orders of performance, you are comparing a GC VM-based managed language to a systems programming language.
I already addressed that in >>106016541
>But Rust requires using its escape hatches in many more cases and much more frequently than for instance Java (though Java is also typically used for different kinds of applications).


>Even if you have to use some Rcs and Mutexes to write whatever algorithm in safe subset of Rust, it is not going to be slower than a GC language where literally everything is a reference counted, heap allocated class instance.
Performance is more complex than that, GC can sometimes outperform reference counting. https://www.reddit.com/r/ProgrammingLanguages/comments/lukgni/comment/gp6zidy
And you failed to address JIT.

>>106018332
>This only applies to some zero cost data structures.
More complete and utter lies.

>>The aliasing requirements are significantly more difficult, as you well know.
>True, but it's not all that hard to get right.
Why do you lie so much? Why are Rust developers often so reliant on Miri instead of being able to figure out the rules themselves? Why do even the Rust stdlib developers fuck up UB? https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/

Continued.

>>106018332
>>106018408
>>106018332
>These are different orders of performance, you are comparing a GC VM-based managed language to a systems programming language.
I already addressed that in >>106016541
>But Rust requires using its escape hatches in many more cases and much more frequently than for instance Java (though Java is also typically used for different kinds of applications).


>Even if you have to use some Rcs and Mutexes to write whatever algorithm in safe subset of Rust, it is not going to be slower than a GC language where literally everything is a reference counted, heap allocated class instance.
Performance is more complex than that, GC can sometimes outperform reference counting. https://www.reddit.com/r/ProgrammingLanguages/comments/lukgni/comment/gp6zidy
And you failed to address JIT.

>>106018332
>This only applies to some zero cost data structures.
More complete and utter lies.

>>The aliasing requirements are significantly more difficult, as you well know.
>True, but it's not all that hard to get right.
Why do you lie so much? Why are Rust developers often so reliant on Miri instead of being able to figure out the rules themselves? Why do even the Rust stdlib developers fuck up UB? https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/

>>106018355
>You could have said the same about Go and it's claims about memory safety, which fall short as soon as you have a data race. It's the same kind of "actually, ..." you are complaining about.
Yes, and I hold that against the Go evangelists, yet they are way less terrible than the Rust evangelists. Why would two wrongs make a right?
And then there is this Rust insanity, backed up by the Rust community at large.
https://archive.ph/uLiWX
https://archive.ph/rESxe
https://lkml.org/lkml/2025/2/6/1292

>Hell, I even seen multiple people on /g/ claiming that all memory problems in C++ can be solved simply by using smart pointers. Does that mean they are dishonest C++/Go evangelists? Or just misinformed newbies who can't RTFM.
Multiple people, or one incompetent, schizophrenic Rust evangelist setting up strawmen to attack? Smart pointers can definitely help in many cases, but it is widely acknowledged in the C++ community that they in no way guarantee or cover the absence of UB.

>>106018332
>>106018355

Damn it, I accidentally deleted a part of my reply.

>>106018408
>I already addressed that in >>106016541
>>But Rust requires using its escape hatches in many more cases and much more frequently than for instance Java (though Java is also typically used for different kinds of applications).
And I also addressed that by saying that there is nothing you can write in Java without unsafe(excluding UB) that you can't write in Rust without unsafe.

>Performance is more complex than that, GC can sometimes outperform reference counting. https://www.reddit.com/r/ProgrammingLanguages/comments/lukgni/comment/gp6zidy
It can, but you can also always write reference counted + borrow checked code that will be faster than any Java code.

Let's make it a challenge. Write any, reasonably-sized algorithm you want in Java and I will write code in safe Rust that does the same thing and we will benchmark. Pro tip: Rust will be faster.

>And you failed to address JIT.
JIT doesn't make Java any less full of reference counted, heap allocated class instances.

>More complete and utter lies.
>Why do you lie so much?
Prove me wrong then.

>Why are Rust developers often so reliant on Miri
I don't.

>Why do even the Rust stdlib developers fuck up UB? https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/
Show me a languge that never had any bug in the stdlib.

>Why would two wrongs make a right?
It doesn't. You are simply biased and fail to realize that the situation you are describing is a commonplace. Every language has newbies who do not understand the language. You seeing these terms like "fearless concurrency" or "memory safety" and assuming they mean something else than they do, makes you part of that group too. In order to properly understand the nuances of any language you have to read the fucking manual, it applies both to you and to the people you are describing.

Imagine how completely dishonest and incompetent a Rust evangelist is when they have to abuse janitorial access to delete the posts of the one they are arguing against, on a dishonest basis.

>>106018332
>>106018408
(Remade reply)

>I rarely write any unsafe in my projects, and if I do, it's usually very simple things like FFI or accessing some low level API.
I have seen Rust developers fuck up even basic FFI and usage of external libraries.
Do you even use Miri? Why did you not address that topic? How many Rust developers can look at code using escape hatches and determine whether it has any UB? How many instead rely on Miri? And Miri has inherent shortcomings, despite how useful it is.
And you may want to run Miri even if you are not using escape hatches yourself, since dependencies can fuck it up.
https://zackoverflow.dev/writing/unsafe-rust-vs-zig/
>A crate you use might have UB
>If you use a crate in your Rust program, Miri will also panic if that crate has some UB. This sucks because there’s no way to configure it to skip over the crate, so you either have to fork and patch the UB yourself, or raise an issue with the authors of the crates and hopefully they fix it.
>This happened to me once on another project and I waited a day for it to get fixed, then when it was finally fixed I immediately ran into another source of UB from another crate and gave up.
Like the Rust stdlib.
https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/

>Lack of UB is one of the essential properties of correct code.
Did you not understand my comment, or are you that incompetent and dishonest? Do you understand and realize the implications of
https://doc.rust-lang.org/nomicon/working-with-unsafe.html
>Because it relies on invariants of a struct field, this unsafe code does more than pollute a whole function: it pollutes a whole module. Generally, the only bullet-proof way to limit the scope of unsafe code is at the module boundary with privacy.

>>106018594
>I have seen Rust developers fuck up even basic FFI and usage of external libraries.
I have seen all kinds of programmers making all kinds of mistakes.

>Do you even use Miri? Why did you not address that topic?
I literally said I don't use it. wtf

>Like the Rust stdlib.
>https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/
Show me a languge that never had any bug in the stdlib.

>Did you not understand my comment, or are you that incompetent and dishonest?
I understood your comment and I said you are wrong. Code that relies on UB is incorrect, therefore:
>Rust generally requires a lot more code than merely those blocks to be correct, to not have UB
is false

>Do you understand and realize the implications of
>https://doc.rust-lang.org/nomicon/working-with-unsafe.html
Yes

oh wow only 2 days for you fags to get off your ass

>>106018015
what?
isn't MBD model based definition? wtf does it even have to do with software?
>>106017947
imagine actually using some faggy LLM for your argument. pathetic cope.

>>106018733
based jannies desu.

>>106018833
argument towards what you retard?

>>106018833
>Model Based Design (MBD) is a mathematical and visual approach to addressing problems associated with designing complex control systems, signal processing, and communication systems. MBD enables engineers to rapidly prototype, test, and verify system designs through executable specifications, automated code generation, and systematic verification workflows. This methodology is fundamental to modern engineering practice across automotive, aerospace, and industrial applications, supporting accelerated development cycles, improved quality, and reduced costs through model-centric development processes that integrate simulation, Hardware-in-the-Loop Testing, and automated validation throughout the design lifecycle.
Yeah, it's basically scratch for aerospace.

>>106018859
>scratch
its not what it is
mbd is a whole framework
you design within a set of constraints and based off that you can then generate code and unit tests
you still end up with code
you can then make an optimization pass

its what rust aspires to be
but rust executed the fundamental idea in the most retarded ways possible

>>106018890
now that i think of it
>aerospace has 100% correct ai gen code
>but you niggergoy get hyped on hallucinating chatbots and put money into the shareholder system

>>105993095 (OP)
I can read it.
I don't know what it means but I can read it.

>>106017866
>>106017904
>>106017947
>using LLMs to argue for you
nigger faggot

>>106019212
>>106018833
autism is a hard handicap.

>>106019212
this. wtf is going on in this shit thread?
MBD has nothing to do with code and everything to do from draft and design all the way down to MRO activities.

it's only blowing up because of all the new meme contracts demand it from their vendors.