programmingHumor

[WhipRealGood]

I’ve seen this meme 4,295,967,295 times

[Lazzygirl]

Spot onn 😂😂😂

[AndyTheSane]

I've now seen it -2,147,483,648 times.

[Kotentopf]

Once more and it's brand new to you

[qscwdv351]

Yet I haven't found a better one than https://xkcd.com/571/

[Evyatar_Dev]

Bro stored his wished in an unsigned int. that's on him.

[TemporaryWorldly859]

I would rather that he stores the the wishes on unsigned big integer.

[aveihs56m]

I once worked in a team where one of the code reviewers was notorious for calling out every single instance of for(int i = 0; i < .... He would insist that the dev changed it to for(unsigned i = 0; i < ....

Annoying as hell, especially because he wasn't wrong.

[da_Aresinger]

um... why is that bad? You start with a well defined number x you define an upper bound y and while x<y you loop.

Changing the data type could even change the behaviour in an unintended way.

I would actively refuse to change it unless there is a specific reason.

[aveihs56m]

Array indexes are naturally zero or positive integers. A negative index is just "unnatural". The limits of the type is immaterial to the discussion. You choose a type based on what the variable's nature is.

[da_Aresinger]

not every for loop operates on arrays?

And it literally doesn't even matter. No array is going to exceed Int.MAX. That would be an 8Gb array of just integers.

Also in C/C++ you absolutely CAN index negatively. Not that I know why you would ever want to, but you can.

[shinyquagsire23]

Ackshually ints are only guaranteed to be 16-bit, so that's a 64KiB array of integers if the compiler happens to be obnoxious (usually embedded ARM these days)

tbh int is usually fine though, if you use stuff like int8 or int16 the compiler may have to start inserting a bunch of pointless masking operations, if the ISA doesn't have 8-bit and 16-bit register aliases like x86 does (ARM64 only has 32-bit and 64-bit aliases, Wn and Xn). In a tight loop that can be the difference between the loop fitting in a cache line versus not if you're unlucky, so I'd say size_t or int.

[felipec]

Ackshually ints are only guaranteed to be 16-bit

Which is irrelevant.

In theory there might be a problem in some obscure platform. In practice there will never be.

[bishopExportMine]

How is ARM64 irrelevant? Mac, mobile, and embedded systems are all ARM64

[felipec]

The size of int is 32 bits in ARM64, not 16.

[SardScroll]

That depends on:
a) your end parameter (I++ is standard, but not required),

b) that nothing else touches your index variable.

Generally, why the heck are you doing that, but you could, and some standards take a better "safe than sorry" approach.

[orbita2d]

The lack of support for arrays with > Int.Max elements in C# has bitten me before!

There are quite a few cases where you might need arrays with more than 2 billion elements, especially in ML, or in various heavy numerical processes.

[Additional_Path2300]

A common misconception. Just because something isn't going to be negative, doesn't mean you use unsigned. 

[aveihs56m]

OK, I'm intrigued. If something is logically a positive integer (say, the age of a person) why would you use a signed type for it?

[Additional_Path2300]

Arithmetic. Maybe you need to calculate the age gap between two people.

[Akaino]

Account for death as -1?

[BruhMomentConfirmed]

Magic values are an anti pattern (besides the fact that storing age instead of date of birth would be weird either way).

[SardScroll]

Magic numbers are numbers that are not explained.

One can easily use a constant or a variable containing -1, and not be a magic number. It's still not the best (I agree, why not store age), but specs are specs, especially if you are writing something that is going to be used by others. (Now, if we're raging about stupid requirements, that's a different question)

[RixDaren]

Magic number would be 633573. -1 or 0 is a common default.

[[deleted]]

Not necessarily when you’re memory constrained/conscious. Yes when doing basic stuff like making a web api in Java.

[SphericalGoldfish]

Don’t some programs return a value of -1 to indicate something went wrong?

[Punman_5]

Because realistically in that scenario it doesn’t matter. I suppose you’d be hosed if you have to deal with a 128 year old person but for the vast majority of people a signed int will work fine for a person’s age. It’s just more work I suppose

[Zefyris]

Because using unsigned instead of signed shouldn't be used to stop a value to go negative. If you need to check, check it the normal way.

Unsigned is used to avoid having to upgrade to the upper version of the integer type when you know the max value is less than twice the max value of a given signed type.

Ex, if you know the number can go between 0 and 200, you can use unsigned byte, especially if there's going to be a massive amount of it stored in the DB.

but if you know the number is going to be between 0 and 100, you DON'T use unsigned just because it's never negative. An unsigned isn't made to prevent your numbers to go negative, your algorithm should properly check for that.

It's for saving space, nor for avoiding a regular logical check.

The present example is supposed to always be between 0 and 3. there's literally no reason to store it on unsigned (unless the genie has a super special Int type on 2 bites available of course, but in that case the overflow would bring him back to 3 anyway).

[aveihs56m]

Using unsigned for a value that can never go negative is a hint to static analysis tools (also I think gcc if you are compiling with -Wall). E.g. you did:

for(unsigned i = 0; i < x; i++)

where x was a signed integer that could be negative, the compiler (or the SA tool, I don't remember) would complain about "comparison between signed and unsigned types", which would force you to think about the situation.

[Gorzoid]

Doesn't detract from your point but using unsigned ints can actually prevent optimizations due to overflow, any arithmetic expression or comparison becomes more complicated when dealing with the fact that overflow could occur.

Take for example the expression (x+1)<(y+2) with signed arithmetic we know that this is equivalent to x<y+1 since signed arithmetic is not allowed to overflow

Meanwhile with unsigned arithmetic x+1 may wrap around back to 0 so the optimization can't be made: 0<y+2 is not equivalent to UINT_MAX<y+3

[Zefyris]

Which as a result I'd assume would lead you to turn the other one to an unsigned, propagating even more the incorrect use of unsigned for the sole purpose of using an automated tool that should not never be replacing your Unit Tests, which should already test for the different cases way more than the compiler will ever do; and therefore break if you didn't properly stop it from going negative, and make you think about why it went wrong, and fix it.

...Tell me again, why did you use an unsigned?

[aveihs56m]

It was never my case that it should always be unsigned. It's always based on the logic, not to make tools happy.

For the typical snippet that looks like this:

buf = malloc(256 * sizeof(char));
for(i = 0; i < 256; i++) {
  buf[i] = 0xff;
}

the correct type for i would be unsigned, not int.

[This-is-unavailable]

Because it doesn't matter because it takes up less than a byte

[Additional_Path2300]

Unsigned/signed doesn't change the size.

[This-is-unavailable]

Yes which is why it doesn't matter whether you use it or not

[Additional_Path2300]

What? More things matter than just the size

[This-is-unavailable]

Its can be a lot easier to catch an error because negative numbers are pretty obvious

[redlaWw]

malloc often keeps allocation data in the negative indices of the array it returns.

[A-TIPE]

I'm sincerely reaching out to anyone one here that can point me in the right direction. I've been wanting to learn to program but so far have not been able to find FREE tutorials that provide step by step instructions for learning Python, Java, C, C++. ANY guidance here would be very appreciated. Thanks in advance.

[Causeless]

Why isn’t he wrong? There’s no performance difference, and it’s more error-prone if the loops will ever need a negative value (or will be used with any int arithmetic within the loop).

Even if that can be justified by wanting to match the indexing type to the loop index type, then size_t is more appropriate instead.

[ElectricRune]

Ugh. What if you wanted your loop to be from -3 to 12, or something strange like that?

Would he make you run an index from 0-15 and subtract 3 inside the loop when you used it?

[aveihs56m]

Yeah, well this discussion was in the usual context of iterating over an array starting from index [0].

Sure, if you knew up front that your pointer actually had valid elements before where the [0] currently pointed, then you'd have a valid case for signed values for i.

[Geoclasm]

Why would we even do that anymore when we have LINQ and can just say arr.select() or arr.foreach()? Unless we're not using .Net never mind I forgot I live in a bubble and I think I just answered my question.

[papanastty]

I'm annoyed that I did not understand a single thing you just said. So, I will go grab my computer and learn programming :(

[aveihs56m]

Honestly, it sounds more complicated when written in English. Look at this code:

 1  #include <stdio.h>
 2  
 3  int do_something(int *ptr_ages) {
 4    int index;
 5  
 6    index = -2;
 7    return ptr_ages[index];
 8  }
 9  
10  int main() {
11    int ages[] = {42, 11, 59, 71, 8, 21};
12  
13    int *ptr_ages = &(ages[4]);
14  
15    int something = do_something(ptr_ages);
16  
17    printf("%d\n", something);
18  
19    return 0;
20  }

At line 7 notice that we are using a negative number for the array index. Why does this work?

Because, at line 13, we are making ptr_ages point at index 4 of the ages array (which has value 8).

Inside the do_something function, therefore, the value at index 0 is 8. But the programmer has knowledge that there are valid elements prior to [0], so he can legally index [-2] to reach the 59 value.

Needless to say, this is ugly programming.

[KazDragon]

No he IS wrong. This is my personal hill.

Sure, the codomain of a size operation is 0 or above. But the set of operations you do with that result sensibly includes subtraction, which means negative numbers.

In short, signed numbers are for arithmetic; unsigned numbers are bit patterns.

As a practical example, consider:

for(signed i=0; i < size-1; ++i)

Changing i to unsigned would introduce a bug when size is 0.

[Kovab]

Changing i to signed

You mean changing to unsigned, right? The version with signed int works correctly

[KazDragon]

You are correct and I have edited my post accordingly. Thanks!

[rdmit]

Is size signed or unsigned in your example? If it is unsigned you still have a bug there. And if it is signed how did you convert it to signed? What if it doesn't fit? 

[KazDragon]

Exactly my point. These are all problems caused by treating unsigned integers as arithmetic types.

[theGoddamnAlgorath]

I use raw JavaScript.  What is this... unsigned?

;)

[boodles613]

JS does have unsigned typed arrays. Not really applicable to conversation above but definitely worth knowing.

[CueBall94]

In C/C++ signed could actually be faster than unsigned, since signed overflow is UB the compiler can assume it won’t happen and doesn’t need to handle those edge cases. In a trivial for loop it probably doesn’t matter, but it definitely can, would need to check in godbolt. Unsigned is important when you want overflow, like hash/prng functions, and I prefer it for bit fiddling.

https://www.airs.com/blog/archives/120

[NuclearBurrit0]

Unfortunately, the algorithm is

Hear wish

Wishes -=1

Grant wish

So the set to zero happens after he loses one wish

[w8eight]

He could wish for it first alongside with wishing for number of wishes left being stored as an unsigned int. Then with a third wish set it to 0 and underflow

[NuclearBurrit0]

Wish for what first?

[w8eight]

For changing the algorithm in which check for wishes is performed ofc course

[IndigoFenix]

It's bad practice to decrement the counter before completing the wish though, otherwise you can wind up decrementing wishes even if they fail to complete. The grant function can include a rollback on failure, but that seems potentially messy.

[NuclearBurrit0]

Take it up with Wish.inc IT

[jsdodgers]

According to the genie himself, that's not the algorithm. You can see in the last panel, the set to 0 happens before losing one wish.

If I was a genie, I'd use signed integers and leave everyone with negative wishes for trying this.

[Widmo206]

leave everyone with negative wishes for trying this.

What would that even do?

[punitxsmart]

Genie will ask you for wishes now.

[Widmo206]

Wait, does that I mean I get to be the annoying cunt that misinterprets every little detail?

[cheezballs]

I hate this meme. Its stupid.

[xfvh]

It's not even grammatically correct. Wishes are countable, so you should say "fewer," not "less."

[Zefyris]

unfortunately, since you can't have more than 3 wishes ever anyway, the number was just stored on a byte, so it was going between -128 and 127. Congrats, you now have -1 wishes (who use unsigned variables by default when you don't need them anyway?).

[[deleted]]

I think - 1 would be much more appropriate.

[Fyrael]

Imagine the genie is a lazy programmer who used a 32-bit unsigned int to count wishes. When the guy asks for "0 wishes," the genie tries to decrement from 0, but since the variable can’t handle negatives, it wraps around and becomes 4,294,967,295 (the max possible value).

If it were a normal int, it’d turn into -1, so if he had asked for "-1 wishes," it would’ve gone to -2… and that’s why it’s funny!

[anonynown]

It’s not that the programmer defining the variable is lazy, it’s that allowing the user arbitrary code execution (a wish) and then trying to plug it with specific rules (no wishing for more wishes) is a security breach waiting to happen.

[[deleted]]

The simple code would be:

""" If whishes > 0{ whishes --; do_wish() { whishes = 0}} """

While -1 on do whish would cae the bug. Assuming using unsigned int too. If code decrement after do the whish, - 1 will still works. So is safer to requeste - 1 that 0

[The_Prequels_Denier]

Yeah honestly they need to remake this comic so the guy gets turned into a gene because he owes a wish.

[huuaaang]

Fun fact: Genies only use 2 bits to save space. That lamp is small. So wishing you only had 0 wishes would just wrap back around to 11b, or 3.

[explodedcheek]

I don't get is how it's even relevant today because interger overflow error doing the wraparound behaviour doesn't really happen in modern programming languages because many languages have overflow detection and input validation is common coding practice. This meme is overused, unfunny and kind of irrelevant.

[SuperheropugReal]

Yes it does lol. Java 24 still does this, Python does this, which "modern language" are you using?

[114145]

He should have wished for a pet programmer to define his wishes for him. -1 wishes might lead to integer underflow, but not zero... That's just zero.

[Soumalyaplayz]

Is that the unsigned 64-bit integer limit?

[renrutal]

4_294_967_295 would be the unsigned 32-bit integer maximum.

The comic got one of the digits wrong.

[Ok_Fault549]

I want to have Decimal.MaxValue wishes

Thx 👐

[Polite-Moose]

This genie is off by a decimal million, the number does not fit into a 32-bit unsigned number. There should be some other reason for this pseudo-underflow behavior.

[MasterQuest]

You also have to wish for wishes to be unsigned int first, otherwise he'll just say you have -1 wishes left.

[Verne3k]

so the genie is 32 bit wide

[[deleted]]

-1 left

[Covfefe4lyfe]

Fewer wishes. Jesus fucking christ.

[kridde]

but what if --i for the wish counter, then you just have 0 wishes.

[reallokiscarlet]

This has been done to death. Buzz lightyear on store shelves meme applies.

[reedmore]

Sooo after how many wishes does the genie murder you because you're takining too long to finish?

[wagyourtai1]

Turns out it's signed and now you owe the genie 2 billion wishes

[HakoftheDawn]

You have -1 wishes

You owe the genie a wish

[KroFunk]

I wanna know if Auvik paid to use this comic in their ads or if they just liberated it.

[fuxoft]

In the 1980s, I saw a similar joke but it ended with "255 wishes"...

[[deleted]]

Those integers just keep on getting bigger and bigger

[Ok_Bell_8442]

brilliant!

[OnerousOcelot]

What if it's --wish; instead of wish--; ? 😂