this post was submitted on 18 Apr 2026
10 points (100.0% liked)

Programmer Humor

32002 readers
1166 users here now

Welcome to Programmer Humor!

This is a place where you can post jokes, memes, humor, etc. related to programming!

For sharing awful code theres also Programming Horror.

Rules

founded 3 years ago
MODERATORS
 

made in gimp, with <3

Context for actual rust programmersI 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;
    }
}

top 45 comments
sorted by: hot top controversial new old
[–] Object@sh.itjust.works 4 points 2 months ago* (last edited 2 months ago) (2 children)

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.

[–] First_Thunder@lemmy.zip 3 points 2 months ago (2 children)

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

[–] onlinepersona@programming.dev 1 points 2 months ago

Is this a comment I'm not flake enough to understand?

[–] bobo@lemmy.ml 0 points 2 months ago (1 children)

random pile of unclear errors

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

[–] Ephera@lemmy.ml 1 points 2 months ago

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...

[–] tatterdemalion@programming.dev 1 points 2 months ago (1 children)

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.

[–] firelizzard@programming.dev 1 points 2 months ago (1 children)

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

[–] WhyJiffie@sh.itjust.works 2 points 2 months ago (1 children)

preferring Rust over Rust? what do you mean?

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

[–] firelizzard@programming.dev 0 points 2 months ago (1 children)
[–] edinbruh@feddit.it 2 points 2 months ago* (last edited 2 months ago) (1 children)

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]
}
[–] firelizzard@programming.dev 1 points 2 months ago (1 children)

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

[–] AeonFelis@lemmy.world 2 points 2 months ago (1 children)

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.

[–] firelizzard@programming.dev 0 points 2 months ago (1 children)

😆 yeah I didn’t read it that hard

[–] AeonFelis@lemmy.world 1 points 2 months ago* (last edited 2 months ago)

In your defense, it's written in the only "modern" programming language that encourage this category of errors.

[–] Grail@multiverse.soulism.net 2 points 2 months ago

I love the rust compiler, it makes debugging so easy

[–] cadekat@pawb.social 2 points 2 months ago

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

[–] Courantdair@jlai.lu 2 points 2 months ago
cargo() {
  cargo $@
  echo So how you doin\' today?
}

Fixed

[–] wisha@lemmy.ml 2 points 2 months ago* (last edited 2 months ago)

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;
    }
}
[–] Prunebutt@slrpnk.net 2 points 2 months ago (3 children)

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

[–] Sibbo@sopuli.xyz 2 points 2 months ago

It is, this meme is just trash.

[–] SpaceNoodle@lemmy.world 0 points 2 months ago (1 children)

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

[–] verdare@piefed.blahaj.zone 1 points 2 months ago (1 children)

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

[–] SpaceNoodle@lemmy.world 0 points 2 months ago (1 children)
[–] WhyJiffie@sh.itjust.works 0 points 2 months ago (1 children)
[–] SpaceNoodle@lemmy.world 0 points 2 months ago (2 children)

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.

[–] fruitcantfly@programming.dev 1 points 2 months ago (1 children)

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

[–] SpaceNoodle@lemmy.world 1 points 2 months ago

Oh, guess my mental timeline is wrong!

[–] WhyJiffie@sh.itjust.works 1 points 2 months ago

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

[–] kibiz0r@midwest.social -1 points 2 months ago

Oh god nix output

[–] BlueKey@fedia.io 2 points 2 months ago (1 children)

output makes no sense

C++ template errors enter the room

[–] SpaceNoodle@lemmy.world 1 points 2 months ago (1 children)

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

[–] marcos@lemmy.world 1 points 2 months ago (1 children)

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

[–] SpaceNoodle@lemmy.world 0 points 2 months ago (1 children)

Well, yeah, templates won't recurse beyond 1,024 levels.

[–] mkwt@lemmy.world 0 points 2 months ago (1 children)

That's an implementation-defined behaviour.

[–] SpaceNoodle@lemmy.world -1 points 2 months ago

I like to pretend that gcc is the only compiler

[–] anyhow2503@lemmy.world 2 points 2 months ago (2 children)

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?

[–] nightlily@leminal.space 2 points 2 months ago

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.

[–] communism@lemmy.ml -1 points 2 months ago (1 children)

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...?

[–] siriusmart@lemmy.world 1 points 2 months ago (1 children)

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

[–] anyhow2503@lemmy.world 1 points 2 months ago

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.

[–] Ooops@feddit.org 1 points 2 months ago

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

[–] kibiz0r@midwest.social 0 points 2 months ago (1 children)
[–] leo85811nardo@lemmy.world -1 points 2 months ago

Deterministic when hit by that weird cosmic ray: ❌❌

/jk

[–] psud@aussie.zone 0 points 2 months ago (1 children)

https://xkcd.com/303/ vs this guy who thinks 20 seconds is a long time

[–] Kolanaki@pawb.social 1 points 2 months ago

"This could take like a hundred milliseconds. It could even take gasp ONE WHOLE SECOND! 😱"