this post was submitted on 18 Apr 2026
408 points (89.8% liked)

Programmer Humor

31064 readers
649 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 2 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;
    }
}

you are viewing a single comment's thread
view the rest of the comments
[–] verdare@piefed.blahaj.zone 7 points 3 days 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 3 days ago (1 children)
[–] WhyJiffie@sh.itjust.works 4 points 2 days ago (1 children)
[–] SpaceNoodle@lemmy.world 0 points 2 days 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 5 points 2 days 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 2 points 2 days ago

Oh, guess my mental timeline is wrong!

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

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

[–] SpaceNoodle@lemmy.world 0 points 2 days ago

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.