Spyke
programmer_humor·Programmer Humorbysiriusmart

rust blasphemy (added context)

made in gimp, with <3

::: spoiler Context for actual rust programmers I was having massive beef with the rust compiler yesterday, every cargo check takes 20 seconds.

And then look at the three functions below, only one of them are Send, if you know why, please let me know.

(Note: value that is not Send cannot be held across an await point, and Box is not Send)

async fn one() {
    let res: Result<(), Box<dyn Error>> = do_stuff();
    if let Err(err) = res {
        let content = err.to_string();
        let _ = do_stuff(content).await;
    }
}

async fn two() {
    let res: Result<(), Box<dyn Error>> = do_stuff();
    let content = if let Err(err) = res {
        Some(err.to_string())
    } else {
        None
    };
    drop(res);
    if let Some(content) = content {
        let _ = do_stuff(content).await;
    }
}

async fn three() {
    let content = {
        let res: Result<(), Box<dyn Error>> = do_stuff();
        if let Err(err) = res {
            Some(err.to_string())
        } else {
            None
        }
    };
    if let Some(content) = content {
        let _ = do_stuff(content).await;
    }
}

:::

View original on lemmy.world
438
Comments71
[object Object]
sh.itjust.works

Rust output is bad? I feel like it's one of the best in terms of telling you where you got things wrong. Nix output when you accidentally get infinite recursion is so bad.

Come to think of it, Nix fits all three better than Rust.

113
tatterdemalionreply
programming.dev

People who've never used Rust or only used it once and couldn't grok it like to meme that Rust is bad to cope.

42
Ethanreply
programming.dev

Yes, preferring a language that’s easy to read and therefore easy to maintain over a language like Rust is definitely coping 🙄

-8
WhyJiffiereply
sh.itjust.works

preferring Rust over Rust? what do you mean?

do you think loosely typed python is easy to read and maintain?

25
edinbruhreply
feddit.it

Yeah, like, who would ever want to

stuff1()?.map(stuff2);

It's much better to just:

err, value = stuff1();
if err == nil 
    return err, nil;
if value != nil
    stuff2(value);

And you might even:

for a in vec {
    vec[a]
}
10
Ethanreply
programming.dev

I totally agree, that Go snippet is absolutely more maintainable. Though you forgot the curly braces and the semicolons are unnecessary.

5
AeonFelisreply
lemmy.world

Though you forgot the curly braces and the semicolons are unnecessary.

Yup. These are pretty big issues. But there are also some minor, trivial, purely-preference-based issues - like returning an error if err == nil instead of when it isn't.

4
First_Thunderreply
lemmy.zip

Ah yes, the good old random pile of unclear errors because you forgot to add the file in git thanks nix

18
boboreply
lemmy.ml

random pile of unclear errors

warning: Git tree '/path/to/repo' is dirty

7
Epherareply
lemmy.ml

Unfortunately, that shows up even when you've just modified an existing file, which is not a problem for it.

And which also happens to be the state my repo is in basically all the time, because I'll change some setting, then see if it works like I want it to before making a commit...

3
boboreply
lemmy.ml

Fortunately, your comment is not relevant at all since I incorrectly posted the warning instead of the explicit error:

error: Path 'path/to/file' in the repository "/path/to/repo" is not tracked by Git.

It even gives you

To make it visible to Nix, run:

git -C "/path/to/repo" add "path/to/file"
2
Epherareply
lemmy.ml

I thought, you posted about the warning, because that's actually easier to see than the error. Because yeah, it does say what you posted, but it's in the middle of like 30 lines of other stuff. When I forget to stage a new file, it almost always takes me 5+ seconds to spot what the problem is. 🥲

2
boboreply
lemmy.ml

For me there was only 1 line beneath that error, it's more visible than the warning. Maybe they improved it, or you started reading from the top?

I just completely forgot about that error because I have an extremely basic config.

1
Epherareply
lemmy.ml

Hmm, that's interesting. For me, it looks like this:

I actually thought, it said somewhere in there, that the file isn't staged, but apparently not even that (anymore?).

You don't happen to be using Lix or something, do you? I've heard that it's supposed to have better error messages, but I was never sure how much better it might be...

Edit: Perhaps I should add that those code locations it shows, are not from my code. Only the modules/terminal/new_file.nix in the second-last line is relevant.

1
anyhow2503
lemmy.world

I get that it's supposed to be a meme, but aside from the first one these aren't even rust stereotypes. Is this a meme specifically for people who haven't used rust, know nothing about rust but have maybe heard that it's a programming language?

82
nightlilyreply
leminal.space

Yeah, part of the point of Rust is that it does exactly what you tell it - sometimes to the point of absurdity. No implicit casting for instance.

30
MoffKalastreply
lemmy.world

And here I was thinking most of our programming problems come from the thing doing exactly what we told it to, but didn't quite think the process through enough. Or at all.

7
Fontasiareply
feddit.nl

This is for people who learnt C++ in 2008 and refuse to believe that they've never fucked up a malloc in their lives

14
limerreply
lemmy.ml

Hah I learned c++ in the 90s and never felt shame for messing up an allocation.

I think when this happens, I have a puddle of memory, the spilled ram “lubricates” the pointers, which often rub against each other. The wasted memory acts like oil does to a rusted chain. It’s helping push the program through the finish line.

Yes, I am having fun here

2
communismreply
lemmy.ml

I mean Rust is definitely known for long compilation times but yeah otherwise I am not sure how any of this is Rust-specific. Maybe by "doesn't do what you tell it to do" they mean the borrow checker and strict compile time checks...?

14
siriusmartreply
lemmy.world

i've edited the post content for context, and a small puzzle for rust programmers

8
anyhow2503reply
lemmy.world

I was actually wondering if this was supposed to be about a specific problem someone has with rust (not like I haven't gotten stuck on some weird corner with rust before), but looking at the meme, that seemed unlikely to me. Thanks for the context.

3
BlueKey
fedia.io

output makes no sense

C++ template errors enter the room

61
SpaceNoodlereply
lemmy.world

Template errors make sense as long as you carefully read the entire error, but nobody has ever actually done that.

16
marcosreply
lemmy.world

You are saying that the error messages terminate at some point?

23
mkwtreply
lemmy.world

That's an implementation-defined behaviour.

1
Ooops
feddit.org

So a narrow but clear win for the Rust compiler still...

39
Prunebutt
slrpnk.net

I thought the rust compiler was supposed to be polite and helpful (unlike gcc, or nix).

31
SpaceNoodlereply
lemmy.world

gcc was unhelpful a couple decades ago. I've found it to be rather helpful in recent years.

9
verdarereply
piefed.blahaj.zone

Yeah, recent versions of GCC have gotten a lot better. I suspect it’s actually because of languages like Rust raising the bar.

8
SpaceNoodlereply
lemmy.world

They literally did. They theorized that Rust influenced GCC's improved error messaging. That could not have happened if GCC improved their error messaging prior to the existence of Rust.

0
fruitcantflyreply
programming.dev

But GCC did not improve their error messages (much) prior to Rust, despite Clang's error messages comparing favorably to GCC even before Rust 1.0 was released, as for example discussed in

https://gcc.gnu.org/wiki/ClangDiagnosticsComparison?action=recall&rev=1

Rust itself is 14 years old, slightly older than above wiki page, and even back then it had great error messages, though they've also improved since. Here's a fun site where you can see how error messages have evolved through Rust's life:

https://kobzol.github.io/rust/rustc/2025/05/16/evolution-of-rustc-errors.html

It's only very recently that GCC has started to catch up, for example with some nice improvements in GCC 15:

https://developers.redhat.com/articles/2025/04/10/6-usability-improvements-gcc-15

6
WhyJiffiereply
sh.itjust.works

no they didn't, yes it could have happened:

  1. GCC: exists, not too good messages
  2. rust gets made
  3. rust gets popular
  4. gcc error messages get improved by good example of rust

gcc is not a dead project. it is continuously maintained. its improvements can be influenced by other projects like rust

0
SpaceNoodlereply
lemmy.world

I know that gcc is still alive. That was implied from my original comment.

What you just outlined is the other commenter's theory I already outlined, and literally describes Rust not coming along after gcc improves its error messaging. Thus, it contradicts my theory that Rust came along later than gcc's improved error messaging.

0
Andrea (Drea) Tamar Pinskireply
hachyderm.io

@SpaceNoodle @verdare
Rust error messages are less friendly in general.
Friendly competition with clang has more to do with the improvement of error messages than rust. Plus priorities of improving error messages came into focus. Folks forgot when it comes to open source it is about what folks think is the priorities from developers rather than consumers.

-1
Prunebuttreply
slrpnk.net

You create a new file and don't check it into git yet.

Nix commands: "I've never met this file in my life!"

8
wisha
lemmy.ml

You are running into the Send Approximation being too conservative. The compiler does not like to see a let binding for a non-Send type and an .await statement in the same scope. It is not (yet) smart enough to know that the non-Send type is already consumed by the time of the .await.

You've already discovered the workaround in your three(). To make it more concise

async fn four() {
    let content = do_stuff().err().map(|err| err.to_string());
    if let Some(content) = content {
        let _ = do_stuff_2(content).await;
    }
}
20
cadekat
pawb.social

Just a guess, but are you missing + Send on your error type?

9
Epherareply
lemmy.ml

Yeah, I was gonna say, that might be the root cause.

In the vast majority of cases, you want Box<dyn Error + Send + Sync>, but folks tend to leave out the Send + Sync, because it looks like additional complexity to them, and because it doesn't cause problems when they're not doing async/await.
It's better to define a type alias, if you don't want that long type name everywhere.

6
mkwtreply
lemmy.world

I've done professional work on an old Unix system where the full build was more than 2 hours, and an incremental stop-rebuild-restart cycle was 20 minutes.

You get to where you really stare at your edits for a while before you hit build.

2
wonderingwanderer
sopuli.xyz

I see the problem: you're not pronouncing it "async effin one... async effin two... async effin three"

Try pronouncing it right then run it again ;)

1