this post was submitted on 18 Apr 2026
437 points (90.1% liked)

Programmer Humor

31258 readers
1421 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;
    }
}

top 50 comments
sorted by: hot top controversial new old
[–] Object@sh.itjust.works 112 points 2 weeks ago* (last edited 2 weeks 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.

[–] tatterdemalion@programming.dev 42 points 2 weeks ago (9 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.

load more comments (9 replies)
[–] First_Thunder@lemmy.zip 18 points 2 weeks ago (2 children)

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

[–] bobo@lemmy.ml 8 points 2 weeks ago (1 children)

random pile of unclear errors

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

[–] Ephera@lemmy.ml 3 points 2 weeks ago (1 children)

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

[–] bobo@lemmy.ml 2 points 2 weeks ago* (last edited 2 weeks ago) (1 children)

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"
[–] Ephera@lemmy.ml 2 points 2 weeks ago (9 children)

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

load more comments (9 replies)
[–] onlinepersona@programming.dev 2 points 2 weeks ago

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

[–] anyhow2503@lemmy.world 84 points 2 weeks ago (3 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 31 points 2 weeks ago (1 children)

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.

[–] MoffKalast@lemmy.world 7 points 2 weeks ago* (last edited 2 weeks ago)

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.

[–] Fontasia@feddit.nl 16 points 2 weeks ago (2 children)

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

[–] limer@lemmy.ml 2 points 2 weeks ago

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

[–] communism@lemmy.ml 14 points 2 weeks 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 8 points 2 weeks ago (1 children)

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

[–] anyhow2503@lemmy.world 3 points 2 weeks 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.

[–] BlueKey@fedia.io 62 points 2 weeks ago (3 children)

output makes no sense

C++ template errors enter the room

[–] SpaceNoodle@lemmy.world 16 points 2 weeks 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 23 points 2 weeks ago (1 children)

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

[–] SpaceNoodle@lemmy.world 16 points 2 weeks ago (2 children)

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

load more comments (2 replies)
[–] Courantdair@jlai.lu 6 points 2 weeks ago

boost::msm errors enter the room

[–] kibiz0r@midwest.social 41 points 2 weeks ago (1 children)
[–] leo85811nardo@lemmy.world 17 points 2 weeks ago

Deterministic when hit by that weird cosmic ray: ❌❌

/jk

[–] Ooops@feddit.org 39 points 2 weeks ago

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

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

Fixed

[–] Prunebutt@slrpnk.net 31 points 2 weeks ago (3 children)

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

[–] Sibbo@sopuli.xyz 55 points 2 weeks ago

It is, this meme is just trash.

[–] kibiz0r@midwest.social 8 points 2 weeks ago (1 children)
[–] Prunebutt@slrpnk.net 8 points 2 weeks ago

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

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

[–] SpaceNoodle@lemmy.world 8 points 2 weeks 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 8 points 2 weeks ago (7 children)

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

load more comments (7 replies)
[–] kubica@fedia.io 30 points 2 weeks ago

cargo delete this_post

[–] wisha@lemmy.ml 19 points 2 weeks ago* (last edited 2 weeks 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;
    }
}
[–] Grail@multiverse.soulism.net 12 points 2 weeks ago

I love the rust compiler, it makes debugging so easy

[–] cadekat@pawb.social 9 points 2 weeks ago (1 children)

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

[–] Ephera@lemmy.ml 6 points 2 weeks ago

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.

[–] PlexSheep@infosec.pub 8 points 2 weeks ago

This is an awful "meme"

[–] Cevilia@lemmy.blahaj.zone 4 points 2 weeks ago

sometimes?! Cargo never makes sense to me!

[–] Noja@sopuli.xyz 3 points 2 weeks ago

First mistake was using async

[–] REDACTED@infosec.pub 2 points 2 weeks ago

It never asks me :(

load more comments
view more: next ›