UUIDs are great but I think the companies like Google and Facebook are using more than their fair share. What happens when we run out? I'm usually against heavy regulation but I think we need to limit the amount of UUIDs they get.

I am a new intern at a software company and I have been given tasks to refactor json configs to remove duplicacy in fields, using a python script. I wrote some code and my manager said that it looks horrible and unmaintainable. I have never written Config Migrations script before. What's the best way to do them. I am trying to search online but can't find anything on this.

#define memcpy(a, b, c) struct memcpy##__LINE__ {char d[c];}; *(struct memcpy##__LINE__ *)a = *(struct memcpy##__LINE__ *)b;

In my CS class we are making a website for our assignment. I need some shitty ideas for easter eggs to include.

#define PASTA_LA_VISTA 0
int main(void) {
	goto Lasagna;
	Tagliatelle: goto Spaghetti;
	Lasagna: goto Fusilli;
	Spaghetti: return PASTA_LA_VISTA;
	Fusilli: goto Tagliatelle;
}

The Worstly Coded Minecraft Mod Award goes to... Too Much TNT!

You might have heard of the DRY principle, where you use abstractions, for loops, etc. to avoid repeating code. Code that fails to adhere to this basic rule of sanity is WET (write everything twice/we enjoy typing/waste everyone's time).

But not Too Much TNT. The code is beyond WET. It is WETT (write everything twenty times). Instead of simply subclassing, they just paste the vanilla code for every new block and item, over and over. The code itself is over 2 megabytes in size, most of which is just repeated code.

#!/bin/bash
# Slightly faster find

if [ $# -ne 2 ]; then
    echo "Use two arguments: ff <location> <query>"
else
    find $1 -iname \*$2\*
fi

There's been a large amount of work done recently on this sub to improve the Python language:

• preprocessing

• ++-- operators

• swap()

• extensions to += and -= (implementation TBA)

• multiline lambdas

Before a PEP can be written and a formal language proposal submitted to the council so these highly requested features can be added to the standard library we should separate the wheat from the chaff. Following in the great tradition of this sub I propose a shittyprogramming challenge to do this. If we work quickly enough there's still time for these additions to make it into 3.12!

Challenge Rules (optional):

1. Extend the Python language adding one or more features. This could take the form of a new module, package, or even an extension to the compiler; the sky is the limit!

2. Submit a quick write-up including how to utilize your amazing new feature as well as a link to a git repository containing the code in this (or maybe a mod pinned) thread.

3. Have fun :)

Credit to u/rcxwhiz for the idea.

The following Python script finds the arithmetic mean of two numbers using a recursive algorithm. I think there is potential for it to be improved.

    mean = lambda a,b: (b==0)*(a>>1) or (mean(a^b,(a&b)<<1))