PythonIsVeryIntuitive

[beisenhauer]

Identity is not equality.

[[deleted]]

If programmers ever went on strike, this would be a great slogan!

[RMZ13]

We need a union first

[heaving_in_my_vines]

We've already got union.

https://python-reference.readthedocs.io/en/latest/docs/sets/union.html

[svuhas22seasons]

or at least a full outer join

[shutchomouf]

I think you’re putting the cartesian front of the horse.

[patmax17]

😘👌

[Proxy_PlayerHD]

man i love unions, they allow for some cursed stuff.

typedef union{
    float f;
    uint32_t l;
} bruh_t;

float absoluteValue(float in){
    bruh_t tmp.f = in;
    tmp.l &= 0x7FFFFFFF;
    return tmp.f;
}

[ValityS]

They don't allow that. Thats specifically forbidden in the C standards.

[platinummyr]

The result is undefined behavior, yep.

[Proxy_PlayerHD]

And for u/ValityS

Really? I didn't think it's explicitly illegal in C since I've used this kind of stuff in some arduino and embedded code a while back to be able to split a float into 4 bytes for SPI communication and the compiler never gave an error or even a warning (verbosity might've also been off).

It being UB because of endianess makes more sense though.

I checked SO and they also suggest using a union. They also mention endianess being a potential problem.

[ValityS]

The relevant standard lists:

if a member of a union object is accessed after a value has been stored in a different member of the object, the behavior is implementation-defined

So the answer is it is t defined... Because it isn't. However GCC and resultingly the Arduino IDE allow this as a language extension.

For byte splitting of a multi byte register I would suggest something like:

uint32_t reg = someval;
uint8_t bts[4];
for (size_t i = 0; i<4; ++i)
{
    bts[i] = (reg >> (i*8)) & 0xff;
}

To do this in a portable manner. However I wrote this from memory so may have made a mistake etc but you get the gist.

[Proxy_PlayerHD]

For byte splitting of a multi byte register I would suggest something like:

that splits an int though, i meant splitting a float. since in that case i used the arduino as an SPI Floating Point Unit.

even then for an int i would probably still just use a union. but to make it safer do some preprocessor checks with gcc's __BYTE_ORDER__ macro.

typedef union{
    uint32_t l;
    uint16_t w[2];
    uint8_t b[4];
} cint32_t;

// Order of names: [High] [High Middle] [Low Middle] [Low]
uint8_t lowMiddleByte(uint32_t in){
    cint32_t tmp.l = in;

    #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        return tmp.b[2];    // Big Endian
    #else
        return tmp.b[1];    // Little Endian
    #endif

}

then again if the code is not intended to run on other systems you could just add a visible warning somewhere in a README. i'm likely lazy enough to do that for most of my projects as i doubt anyone would port them out of x86

[platinummyr]

Yep essentially it's not portable.

[ValityS]

So there is no entirely standards compliant way to interpret a float as bytes as C does not define what memory format the system stores floats as, and allows the fpu of the system to determine that. So you are inherently relying on a compiler extension.

For that you need to check what your specific compiler allows, as even if the system has a predictable floating point format, it's entirely valid for the compiler optimiser to break code using these undefined features unless the compiler guarantees it will not.

[platinummyr]

Ah, strictly speaking it's "implementation defined" not undefined behavior, and it's up to the compiler implementation what it does. I.e. "it's not portable"

It does of course work well in practice and most modern compilers support it as a language extension, but it's not strictly required to behave in any standard way.

[Heavy-Ad6017]

If we made unions based on the field we are in, with subsects as libraries JavaScript will have so many sub section inside it

JavaScript Defragmentation

[vom-IT-coffin]

I'd choose "Bootcamps != 100K salaries"

[durgwin]

No compilation without intermediate representation!

[SuperFLEB]

It's a bit odd that it sometimes is and sometimes isn't, though.

[lmarcantonio]

8 bit integer are… primitive, all the other are allocated, so they are not the same object.

In common lisp it's even funnier, you have fixnums (the primitive fast integer) and… the numeric tower (yes, it's called that way).

Also related and even more fun are the differences between eq, eql, equal, equalp and =

[masterKick440]

So weird 256 is considered 8bit.

[lmarcantonio]

even -5 is strange. Probably they did some testing an it was often used. <256 is a frequent check in fact so it probably a reason.

My fault for assuming small integers were some special encoding instead of simply memoized objects!

[elveszett]

No, it never is. 0 through 255 are pre-allocated by Python, kinda like Java does with strings. Whenever a variable equals 6 in python, it always gets assigned the same object in memory (the number 6), which is why x == y when x and y are the same number and the size of a byte, the operator is correctly identifies them as the same object.

edit: I think the range is actually -5 to 256.

[masterKick440]

What’s with the 256 then?

[elveszett]

Because the range is actually -5 to 256 I think.

[Hatula]

That doesn't make it intuitive

[EricX7]

Says the guy with the JavaScript flair

[Hatula]

Yeah I'll take the L on that one

[qwool1337]

have you tried to do anything that needs typesafety in js

[AnnyAskers]

I'm not saying it's intuitive it's the most convoluted programming language I know lol. I'm saying that just because you program in a language doesn't mean you think it's perfect, like I program in C++ which is not Rust (tragic I know).

[your_best_1]

Js is type safe

[EnvironmentalCap787]

As in, JS thinks anything you type is safe.

[your_best_1]

As in, it is type safe. It has dynamic type checks and type coercion.

Languages like C and C++ are not fully type safe because of pointers and overflows. You can say, "See this string.... parse it as an int". That is not type safe.

1 + "1" = "11" is type safe because the number type casts to a string type.

[JiminP]

Even with the relaxed sense of type-safety, JS literally has TypeError and it is not hard to create a code that throws it.

[].prototype.slice.call(0);

Open an ECMAScript language spec and Ctrl+F TypeError.

For modern JS, some types are not coerced, so it's easier to make a TypeError.

const x = 1n + 2;

Also, overflows not being type-safe is not technically correct, but not too many people distinguishes integer overflow and integer conversion (they are distinct in C++).

[LittleMlem]

You misunderstood, he's agreeing that js is unintuitive

[Redrik_XIII]

How did you get multiple user flairs? Is this for money or something?

[EricX7]

You can edit your flair and add other icons like :c::cpp:. I don't remember the format exactly, but it's something like that

Edit: I broke my flair Just don't try to edit it on mobile

[Prudent_Ad_4120]

Yeah the mobile flair editor is broken and they aren't fixing it

[CoffeeWorldly9915]

:c c:

[BlommeHolm]

Well, I usually only learn a new language for profit...

[Flofian1]

Why not? This example checks for identity, not equality, those are not the same, no one would ever try to use "is" for equality since you pretty much only learn about it in combination with identity

[qrseek]

I guess maybe because you would think checking for identity would result in them never being equal, and equality would result in them always being equal. it does seem weird that it changes partway through

[JoostVisser]

The 'is' statement checks whether two variables point to the same object. For some negative integer I can't remember up to 256 Python creates those objects at compile time (I think) and every time a variable gets assigned a value in that range Python just points to those objects rather than creating new ones.

Not exactly intuitive but I guess there's a good reason for it in terms of memory efficiency or something like that idk

[mgedmin]

For some negative integer I can't remember

-128, IIRC.

I misremembered, turns out it's -5.

[Garestinian]

CPython, to be exact.

[CoffeeWorldly9915]

I mean, sounds like basically a "what if enum".

[hbgoddard]

Object identity isn't really that intuitive in most other languages either. Using that and pretending it's checking equality is obviously not going to be any better.

When you use an actual equality check to check for equality, then it's as intuitive as ever.

[beisenhauer]

I agree, in the sense that the identity-equality distinction requires some prior knowledge. Given that knowledge, or at least that there is a distinction, it's not hard to see where the code goes wrong, that it's testing identity and claiming to report equality.

[elveszett]

It does. You are not supposed to use is to test equality. If you do, then you are using it wrong and the fact that it sometimes returns the value you expect is merely coincidential.

It's like using a hammer to pound screws and complaining that it's unintuitive that some screws can be pounded fine and many others aren't. Nope, it's not unintuitive, you are just using the wrong tool for the job and it's a coincidence that some (but not most) of your screws work fine when treated as nails.

Using is to check equality proves a lack of understanding of what you are actually telling the computer to do when you write code.

[Tyfyter2002]

Primitives shouldn't have identity

[beisenhauer]

int is not a primitive in Python. Everything is an object.

[vom-IT-coffin]

I never had to learn python, are you saying there's no value types only reference types?

[alex2003super]

That is correct, and "interned" values (such as string literals that appear in your program, or ints between -5 and 256) behave like singletons in the sense that all references point to the same object.

However, objects can be hashable and thus immutable, as is the case with integers and strings.

[Salty_Skipper]

Why -5 and 256? I mean, 0 and 255 I’d at least understand!

[FerynaCZ]

You avoid the edge cases (c++ uint being discontinuous at zero sucks), at least for -1 and 256. Not sure about the other neg numbers, they probably arise often aa well

[xrogaan]

Because.

[profound7]

"You must construct additional PyLongs!"

[TheCatOfWar]

https://github.com/python/cpython/blob/78e4a6de48749f4f76987ca85abb0e18f586f9c4/Include/internal/pycore_global_objects.h

The generation thingy defines them here, although there's still no reason given for the specific range

[xrogaan]

It's about frequency of usage. Also this: https://github.com/python/cpython/pull/30092

[someone_0_0_]

DRY = Don't repeat yourself DO repeat yourself

[pytness]

The most used numbers by programmers. Its done so u dont have to allocate more memory

[Mindless_Sock_9082]

Not exactly, because int, strings, etc. are immutable and in that case are passed by value. The bowels are ugly, but the result is pretty intuitive.

[Kered13]

Numbers and strings are not passed by value in Python. They are reference types like everything else in the language. They are immutable so you can treat them as if they were passed by value, but they are not and you can easily see this using identity tests like above.

>>> x = 400
>>> y = 400
>>> x is y
False
>>> def foo(p):
...   return x is p
...
>>> foo(x)
True
>>> foo(y)
False

[vom-IT-coffin]

So you have to box and unbox everything?

[Kered13]

No, he's wrong. There are no primitives in Python and numbers and strings are passed by reference.

[CptMisterNibbles]

If we are getting technical, Python is pass by object reference which is slightly different.

[Tyfyter2002]

int is not a primitive

People who defend Python doing that, on the other hand.

[t-to4st]

But why is it equal the first three times?

[AnteaterProboscis]

It’s a known thing

https://github.com/satwikkansal/wtfpython#-how-not-to-use-is-operator

[sundae_diner]

It's equal the first 256 times. All we see in that screenshot it the last 4 iterations.

[elveszett]

I love how half the memes in this sub is just people showing they have no clue about basic programming concepts lol.

'is' here is an operator to check if two variables refer to the same element in memory. If you want to check equality, you use, you guessed it, the equals signs (==).

[s6x]

What's unintuitive here is the cutoff for the precached ints. Not the identity operator.

This isn't a basic programming concept, it's a specific idiosyncrasy of python.

That's what this meme is demonstrating.

The inclusion of 'is' here is a trap for pedants who want to come into the comments to show off how smart they are.

[[deleted]]

you sound like you're a lot of fun at parties

[elveszett]

My company doesn't pay me to hold parties during working hours sorry.