The easiest problem

I present to you quality variable names. (and a Mount Rustmore)

(Reconfigure(f), 'c') => {
    let mut p: Vec<&str> = vec![];
    loop {
        match args.next() {
            Some(k) => {
                if k == "=" {
                    match args.next() {
                        None => q("need value for Rc"),
                        Some(v) => u(
                            f,
                            |f| Box::new(
                                |c| {
                                    f(c);
                                    c.set(p.iter().copied(), v);
                                    for e in p {
                                        unsafe {
                                            Box::<str>::from_raw(
                                                std::mem::transmute(e)
                                            );
                                        }
                                    }
                                }
                            )
                        )
                    };
                    break
                } else {
                    p.push(Box::leak(k.into()));
                }
            }
            None => error("need path element or = for Rc"),
        }
    }
},

(Reconfigure(f), 'c') => {
    let mut p: Vec<&str> = vec![];
    loop {
        match args.next() {
            Some(k) => {
                if k == "=" {
                    match args.next() {
                        None => error("need value for Rc"),
                        Some(v) => update_in_place(
                            f,
                            |f| Box::new(
                                |c| {
                                    f(c);
                                    c.set(p.iter().copied(), v);
                                    for e in p {
                                        unsafe {
                                            Box::<str>::from_raw(
                                                std::mem::transmute(e)
                                            );
                                        }
                                    }
                                }
                            )
                        )
                    };
                    break
                } else {
                    p.push(Box::leak(k.into()));
                }
            }
            None => error("need path element or = for Rc"),
        }
    }
},

I worked with a developer who insisted on using the shortest names possible. God I hated debugging his code.

I’m talking variable names like AAxynj. Everything looking like matrix math.

Nah, I name all my variables after my homies.

int dave = 0;

installing operating system: 15 minutes, give or take.

give a name to the computer: 45 minutes

You should really be naming all your variables by generating 64 character (minimum) random strings.

FullSentenceExplainingExactlyWhatItDoes(GiveThisVariable, SoItCanWork)

Older C compilers would truncate a variable name if it was too long, so VeryLongGlobalConstantInsideALibraryInSeconds might accidentally collide with VeryLongGlobalConstantInsideALibraryInMinutes.

Legend says that they used to do it after a single letter with Dennis declaring "26 variables ought to be enough for anyone".

Gotten even easier after X became a registered trademark. Now the only choice we have left is i. Or ii if you need more variables

An important professor constantly and frustratingly said

we can call this variable whatever we want, so we’ll call it Fred

Made me panic and irate and focus on the wrong part of the problem. Every. Single. Time.

Single character variable names are my pet peeve. I even name iterator variables a real word instead of “i” now.. (although writing the OG low level for loops is kinda rare for me now)

Naming things “x”.. shudder. Well, the entire world is getting to see how that idea transpires hahah

Then you realize your code is undebuggable because half the functions and variables have single-letter names or called foo, bar, baz, etc.

There are only two hard things in computer science: cache invalidation and naming things.

Why is no one giving credit to my friend n?!

name your function as malloc() and see to world burn and generate bugs at factorial rate.

for whatever in stuff:

How to write spaghetti code:

Since a lot of the english words i know i learned from minecraft, in a farming simulator i named tilled soil"hoed"

I had multiple variables like int isHoed

mathematician here, where is the joke?

Just be careful naming your function "stdout()" or things could get weird...

Now I want to become a programmer so I can give variables people names.

No, that's math.

Am I being gaslit?

Was just talking about gaming genre names being kinda lame (roguelike? Souls-like? Where's the originality?!) and this just furthers my point as programming and video games are intrinsically linked.

It took me too long to figure out the I in an if statement was just integer

Ok, but what variable is 🐈?

^- triggered

How dare you.... <Eye squint>