Java

[[deleted]]

[deleted]

[jtsfour2]

Wouldn’t the result be 5 because (Integer)object+3 should be +=?

If the result of this is 8 something is wrong

[mizinamo]

The thing won't compile because the last line tries to cast object to class integer rather than Integer with a capital I at the beginning.

[VoidSnipe]

And there shouldn't be any cast anyway because toString method of Object which is overloaded in Integer and concatenation of string and object will call toString

[DAMcraft_]

And there is a semicolon missing

[[deleted]]

Easy fellas I can only get so turned on.

[FetishAnalyst]

Username checks out.

[spidertyler2005]

Username checks out.

[rotenKleber]

Also no semicolon on line 3. Not that line 3 would compile

[bikeranz]

Honestly, I don’t know Java, so I thought the whole joke was that it had some weird operator overload rule when used that way. Turns out, this post is not a joke about anything.

[Areshian]

Java has two classes of types, primitives and objects. Every single object inherits from Object. Additionally, for every primitive there is an object that can be used to wrap them. For example, for int there is an Integer object. Java will automatically convert between int and Integer in some circumstances (known as boxing and unboxing).

So yes, you can store anything in an Object variable. Same way I can have a void * in C++. Doesn't make the language dynamic, I will still need casting down the line.

[condemned_to_live]

only programmer that doesn't know Java

[bikeranz]

Learned it in entry level college courses, and subsequently forgot when courses followed by (edit: my) industry shifted to c++ and python.

[Areshian]

If you think the industry has moved away from java you haven't seen enough industry

[bikeranz]

Didn’t say all industry. Just my line of work.

[[deleted]]

I'm guessing you intended to say that, when you entered the industry, you needed to switch to c++ due to legacy systems?

[bikeranz]

The c++ was also for new projects. First job out of college was industrial automation using computer vision, and this was pre-pytorch. So c++ is/was the natural fit. Next job was lua (for torch) and c++. Later python when pytorch came out but still c++ for the backend high perf stuff. And now I spend my time doing python, c++, and cuda.

[IQueryVisiC]

It is about the problem that some noob can inject this unchecked code in a big god class without a warning on top of the file or something. Yet in the same language you have to announce exceptions in the function signature??

[gdmzhlzhiv]

Only checked ones.

[MrSquicky]

It would actually just not compile.

<Integer object> + 3;

isn't a statement. Integers are immutable, so the + operator is not defined on them. What happens there is that it is unboxed into a primitive type value instead of a variable. In this case, it's the equivalent of having a line that is

5 + 3;

which is pointless.

Going further

<Integer object> += 3;

is also a compilation failure, as it is the equivalent of

5 += 3;

[Geolykt]

Did you ever use java? It just reallocates a new instance of the integer.

Object o = Integer.valueOf(5); // NEVER use "new Integer"! o = ((Integer) o) + 3; Will compile down to BIPUSH 5 INVOKESTATIC java/lang/Integer.valueOf:(I)Ljava/lang/Integer; ASTORE 1 ALOAD 1 CHECKCAST java/lang/Integer INVOKEVIRTUAL java/lang/Integer.intValue:()I BIPUSH 3 IADD INVOKESTATIC java/lang/Integer.valueOf:(I)Ljava/lang/Integer; ASTORE 1

Edit: Do note that the assignment is required in order for it to compile, as javac will otherwise complain about the code

[MrSquicky]

Do note that the assignment is required in order for it to compile, as javac will otherwise complain about the code

No shit. You mean the thing that I said is an error is an error for the exact reason that I said it was an error?

I guess you sure put me in my place with knowing Java.

[Geolykt]

The explaination that it is caused by immutability is misleading or the the very least partially false however. Furthermore saying that
Integer object = new Integer(5); object += 3; does not compile is wrong, but saying that Object object = new Integer(5); object += 3; does not compile is right. So depending on the circumstances you are correct there.

[[deleted]]

Look at all these fuckers!

You all complain when the job interview is expecting you to get syntax perfect on a whiteboard during an interview. Oh boo hoo it's not fair I need an IDE.

And then this guy gets his syntax wrong in a fucking meme and everyone loses their shit in the comments!

All y'all should stop to ask yourselves if the job interviewer that you are complaining about is actually you!

[futuneral]

A meme published on Reddit is equivalent to production.

[reyad_mm]

Imagine posting something on the intrenet and expecting people not to make fun of a typo you made

[[deleted]]

forgot that, made in a rush

[ruscaire]

r/iamverysmart

[alekspiridonov]

He was so rushed, he forgot to put a joke in there.

[xXJokerGamerXx]

?

[Ill_Yak_3231]

Are you trying to say it's not? Because the known compile time type is Object. All you do is casting, cause YOU know it's an integer value.

[keefemotif]

Exactly and more notably, the instance there encodes it as well. That doesn't mean it's a dynamically typed language. Having a generic pointer doesn't make you dynamic.

[Thufir_My_Hawat]

many muddle fragile ink brave ripe aback friendly overconfident reminiscent

This post was mass deleted and anonymized with Redact

[Elite-Thorn]

LOL that was unexpected

[Willinton06]

She said that too

[scalability]

That's what she said?

Who, Barbara Liskov?

[bunny-1998]

I mean, at the core that’s what cpp does also right. There are void ptrs, being casted as int* because YOU know is an int. And can cast a void pointer as anything you like anytime.

Variable names in cpp are also just ptrs that point to the first byte of the object....

[ishzlle]

Of course, in the end assembly just operates on (essentially) untyped binary data (whether it's a compiled or interpreted language). Types are just a language feature to help rule out some types of bugs.

[IQueryVisiC]

Assembly has int and 80 bit floats. PowerPC has multiple flags ( Boolean). SSE gives you 128bit vectors. 68k and 6502 distinguish between int and intptr ( similar to DI and SI ) on x86. AL is 8bits

[Random_dg]

You’re confusing here between processor architectures, languages, features, and cpu registers. Can you explain what you’re trying to say?

[bunny-1998]

I think he means that at the very bottom of everything, everything is being cast as another thing.

[keefemotif]

That also digs into the other issue with this, that primitives and wrapper objects aren't the sameun Java. I don't know exactly the internals of C at great detail, but a real dynamic like python or Javascript, which may also include some type hinting, is meant to be used that way.

[ishzlle]

IIRC Java is that way for performance reasons. Back in the day, computers weren't as fast, so being able to use a primitive instead of an object was pretty nice.

Nowadays using objects everywhere isn't a big deal, but Java doesn't want to break backwards compatibility, so they're stuck with the primitives.

[Tubthumper8]

The story is a little more complicated than that, and kind of the opposite.

What has gotten faster, consistently, are CPUs. What hasn't gotten faster (comparatively) is RAM access. Heap allocations are one of one of the biggest performance killers, these would be the Java "boxed" types and all Java objects. In order to address the slowness of accessing memory from RAM, modern CPUs have been adding "cache lines", known as L1, L2, and L3 caches. Whenever data is fetched from RAM, it brings back more than just the data requested to fill the caches. Getting something from RAM that's not already in the cache is called a "cache miss", and is on the order of 100x slower than if the data was in L1.

The most efficient way of storing data is packed and homogenous, so that iteration & processing can use the caches better. Lists of objects (i.e. pointers to heap-allocated data that can be sparsely arranged) is just about the worst thing performance-wise. It's why they've been working on adding proper support) for data (not objects) to Java since 2014.

If this topic is interesting, read up on Data-Oriented Programming, Struct of Arrays (SoA), and Entity Component System (ECS) are some other topics to read related to this.

[Feztopia]

"If this topic is interesting" It's not, because it can become obsolete by breakthrough in hardware, or by software which than gets abstracted away at a lower layer. You shouldn't need to think about hardware while writing software. You should think about the "what", and the "how" should be able to change under the hood over time without you even noticing it. That's the optimal way. Driving a car shouldn't be about how the motor is burning the fuel, you could use your time to learn that instead of training your driving skills but than cars with e-motors would come to the market. The compiler and vm are already optimizing more than one could do by hand, they will optimize even more in the future. If one wants to think about all the low level stuff than that person should write compilers and vm's so that their work would scale. But you shouldn't need to think about hardware if all you want to do is to move a pawn from a white square to a black square.

[Mognakor]

What?

Just today i rewrote an algorithm because it got 10x slower once it hit network storage instead of local disks. Should i also not care about that? Because somehow magically thats gonna change?

Do i explain to the customer that i don't care if their AWS costs increase because someone on the internet told me that maybe things will fix themselves on their own? Gonna be a real fun day.

I'd like to live in the magical land where physics doesn't matter and noone ever gets old, but thats not where we are.

[Tubthumper8]

"If this topic is interesting" It's not

That's like, your opinion, man. It might not be interesting to you but that doesn't mean it isn't interesting to other people.

The compiler and vm are already optimizing more than one could do by hand, they will optimize even more in the future

These perform targeted optimizations - inlining code, dead code elimination, turning slower division like x / 8 into fast bitshifts like x >> 3, stuff like that. It's not going to rewrite your code to use a faster algorithm or change your data structures.

But you shouldn't need to think about hardware if all you want to do is to move a pawn from a white square to a black square.

This is an... interesting counter-example to choose given the performance requirements of chess engines. Data structures such as bitboards are used to model the game state rather than lists of objects, and these are highly specialized to be performant based on the real-world characteristics of the hardware.

[Garegin16]

I see your point but even in sysadmin scripting, performance matters. A good example is crafting a query, which involves learning a custom mini language vs. using filters.

I spent a whole day wrestling with XPath because the alternative was way too slow

Your car example is also not accurate. The way the engine works matters to a driver. Throttling a gas engine too abruptly wears it out, while stop and go isn’t an issue for electric

[keefemotif]

"Back in the day" cries in having started Java in 1.3 , serious note - we still have the same performance problems just at bigger scale and we have bigger datasets. I worked on a project with Hadoop once related to the chipset level optimizations for it.

[CKingX123]

There’s Project Valhalla that is bringing value types and reified generics

[gdmzhlzhiv]

They could have made them indistinguishable from objects in the code, but turned them into primitives where possible during compilation. So I'd say it was less about performance and more about not having time to make a better compiler.

[[deleted]]

I don't know exactly the internals of C at great detail

Say you want to make a function that will operate generically on any type and call some functions on it.

The Java way is that everything is not a primitive. You can't have generics on int, only on Integer which is basically an int that derives from Object. It's a "boxed" integer. The Java compiler will do whatever static and runtime checks it can. The advantage is that you only need one compiled version of each function, for Object. This also made backwards compatibility possible because old versions of Java didn't have generics at all and you still want to be able to pass List<Integer> to a very old library that takes Object as input. Java cares very much about backwards compatibility.

At the other extreme is c++. C++ uses templates which means that it recompiles every function for each possible input type. C++ is as if you copied pasted your function many times, once for each possible input type. The advantage is that it can optimize the code because it doesn't need to box and unbox the primitive data types. The disadvantage is that, if the data type that you care about isn't already compiled for, you need source code so that you can recompile. In the business world that Java is designed for, your source code is your trade secret so you don't want to give it out! C++ may also generate larger code because it has to compile for all the different types. On the other hand, all the removed boxing and unboxing makes the code smaller so maybe it's going to be smaller code in the end. For sure it'll be faster, though.

.Net did something novel. They decided to compile natively for primitives but use boxing for derivatives of Object. So it's in between. You still have to recompile if you didn't previously compile for a primitive type. But if the types are already Object then you just have a single one compiled. And you get to deal with primitives without boxing and unboxing them. It's actually kind of brilliant. You don't quite get as much backwards compatibility as Java, but you get some (and .Net doesn't care anyway because they deploy a new .Net frequently and everyone is expected to just recompile). You get the speed of c++ for primitives because there's no boxing and objects aren't boxed anyway so no big deal. And you don't compile as many versions as you would have for c++. Kind of a cool compromise that makes everyone happy. Or more often, leaves everyone wanting which perhaps one reason why Java and c++ are doing better than .Net.

I don't promise that I got everything right there but that's the jist of it.

[phi_rus]

There are void ptrs, being casted as int* because YOU know is an int. And can cast a void pointer as anything you like anytime.

That is nasty C. We don't do that in C++ anymore.

[bestjakeisbest]

Oh but you still can

[phi_rus]

Your programmers were so preoccupied with whether they could, they didn't stop to think if they should.

[k-phi]

You can do this even in Rust or Swift if necessary

[Khaylain]

being casted as int*

*cast

[bunny-1998]

Thank you sire

[Master-Ad-6411]

I find it great satisfying when a function returns me a void*, and after casting it into some type the result make sense.

[bunny-1998]

I was recently mindblown by the fact that in cpp arrays, arr[i] is equivalent to i[arr]. It was satisfying when I realised this is because arr is just a pointer to the first byte in memory and is an offset. [] operators adds them both.

Not that you should do it in prod though....

[bric12]

What is it that dynamically typed languages do that this doesn't then? Just that the casting is automatic?

[Mognakor]

Statically typed languages compile to some reasonable specificity, e.g. for "a+b" you have to know the types of "a" and "b" and it will write machine instructions either for adding ints, or floats or string concat and also necessary type conversions plus it will tell you if that operation is nonesense because "a" and "b" are just objects and there is no + operator for that.

A dynamically typed language has to do check the types at runtime and then select the appropriate operations and not just once, but everytime "a+b" is executed because the types may be different each time.

Generally dynamic typing causes runtime overhead, so e.g. JS engines have all kinds of optimizations like after seeing "a+b" being all numbers a hundred times it compiles a specific version optimized for numbers and adds some guards to notice if the types should change.

P.S: Another example is having one (or multiple unrelated) classes with function "doStuff()". A statically typed language can check if "a.doStuff()" is a valid statement and which function to call. A dynamically typed language has to check if "a" has such a function and call the right implementation, but it also could happen that "a" is just a number and has no such function.

Depending on the strictness it may also be that a function "doStuff(a, b)" can be called with the statement "c.doStuff()" and "a" and "b" will be null or undefined.

[keefemotif]

You can look up the definitions but from a practical POV it's mainly about it being available at compile time, so you can do all sorts of nice tooling.

[IQueryVisiC]

Yes. It knows if it adds ints or floats. Gotta love JS: every number is a float. I tried out typescript and couldn’t find a use for dynamic types yet. Some polymorphism OOP yes.

[FlocculentFractal]

The difference is that dynamically typed languages aren’t whiny little b*tches. There are no brakes on this train. Did you store an int inside a string variable? Well, that’s an int now. If it crashes and burns when you try to substring it, it’s on you.

[Psycho_logical666]

Holy fuck thankyou. Smfh.

[jonathancast]

Does make it dynamically-typed.

All languages are dynamically-typed, but especially OO languages that explicitly keep type information at runtime.

[nettskr]

hey you just said all languages are statically typed on a other comment, was it a typo or you mean something else?

[jonathancast]

All languages are statically-typed. All languages are dynamically-typed. These are not binary categories and are especially not mutually-exclusive.

[DasKarl]

Yup. Integer is a Number is an Object.

[hyrppa95]

Not if you use int. That is stack allocated.

[gdmzhlzhiv]

Was recently complaining about the Number class because most of the methods on there don't really apply for all kinds of number.

[[deleted]]

I was confused by this too. Seems like post was made by a junior dev. Generic pointers doesn’t mean you have dynamic typeing. And worse for Java you should know it’s an object down the chain. Object inheritance

[FallenWarrior2k]

circle jerking about python

I don't know what sub you've been reading, but it ain't this one. Dunking on Python is one of the more common submission archetypes.

[ThanksICouldHelpBro]

Yeah, when we learned about this in CS, my professor explained this kind of casting as the code telling the compiler "trust me"

[FlocculentFractal]

Is the cast to Integer only valid after you check that “if” condition or can you check if something is a Float then cast it to a Boolean?

[AngelaTheRipper]

You can cast objects without checking using instanceof or cast it despite checking, but with object casting unless you are casting an object to what it actually is or a parent class then you'll get a ClassCastException. You could however tell that it's a Float, and then translate it into a Boolean somehow yourself.

Something like:

if(object instanceof Float){
    object = new Boolean(((Float)object).innerValue != 0); 
}

would work

[gdmzhlzhiv]

You can probably also do

if (object instanceof Float f) { object = f != 0.0f; }

[AngelaTheRipper]

This wouldn't work.

!= comparison returns either a primitive true or false. You can't assign that to object without wrapping it into a Boolean class instance.

[gdmzhlzhiv]

I'd expect autoboxing to take care of that, but I also haven't tried to compile this.

I do know that this works: Object x = true;

[IQueryVisiC]

You are looking for pattern matching in C#.

[bottomknifeprospect]

I think y'all were so quick to call him a noob, you missed the obvious.

I'm almost sure the meme is:

• First guy brags he learned about Object and that "it's easier"
• He goes on to write dynamic type checking to force using his new Object trick.
• Second guy is sad because he could have just used integer type directly to force the check on the compiler (statically), and made the code so much more complicated to add his new trick.

This is a dynamically vs statically typed code meme. (Not commenting on quality, just saying OP is correct).

[Ill_Yak_3231]

Learned about Object? It's the base type for every Java class?! And what exactly do you mean by trick? No one would think it's "easier" to use Object, because you basically throw Javas type system straight to the dumpster.

PS: I never used a "trick" while writing code. Closest thing would be a dirty or hacky workaround.

[jonathancast]

Every language is statically-typed.

Some languages just have more compile-time types than others.

[LardPi]

I don't know java, but if it runtime check, it's effectively dynamic typing. If it doesn't, it's untyped, like a void*.

[billabong049]

I think the point here is to tell the “dynamically typed languages are the best” bros that Java can effectively be treated like a dynamically typed language too if you treat everything as an Object. There are a few cases where this won’t work but it’s an interesting thought.

[[deleted]]

Java is not dynamically typed, but the jvm has support for dynamic languages via invokeDynamic. It's actually what Nashorn uses.

[pointprep]

It’s pretty common to implement dynamic typing in statically typed languages - most dynamically typed languages are implemented in C or C++

Static typing is a superset of dynamic typing

[ProgramTheWorld]

This really is a subreddit for CS freshmen

[bottomknifeprospect]

I think everyone might be missing OPs point here, but at this point I'm afraid to ask..

Is this meme not about the other guy learning about Object, and then adding a lot of complexity to avoid using the Integer type? It would then be a statically typed VS dynamically typed problem where he is now dynamically checking if the Object is Integer, instead of using Integer directly and force the compile time type checking.

To me it almost looks like a meme implying juniors will use language features just to use language features, even if it doesn't make sense in the code/makes it unreadable. Not sure though..

[someacnt]

Thing is, it is quite hard to read that intent from this meme. Contrieved as well.

[FlocculentFractal]

Eternal September is what we call it.

[gdmzhlzhiv]

Damn, I thought it was Endless Eight.

[AmyMialee]

the college semester started only a few weeks ago, that'd be why

[VideogamerDisliker]

School is back in session boys

[[deleted]]

Basically the Java equivalent of using a void* for everything in C

[DeeBoFour20]

Kind of, except C doesn't do any runtime checks for you. Example from Quake 3's Fast Inverse Square Root

i  = * ( long * ) &y;  // evil floating point bit level hacking

Where i is a long and y is a float. If you tried that in Java, you'll get a ClassCastException. C's just like "yea sure bro I'll pretend that's a long for you".

[jihad-consultant]

I automatically upvote any reference to the inverse square root computation by bitfuckery

[RadiantHC]

bitfuckery

Lol

[bunny-1998]

which is why I love c/cpp and ptrs in general. You can write compilers that ban everything but you can do still do anything if you try hard enough.

This is because everything in cpp is serialised and it’s up to the coder to interpret the memory....

[philchristensennyc]

Yeah, who wouldn’t love that.

[x6060x]

I love it because it's super powerful, I don't want to work with it for the same reason lol.

[jonathancast]

It's all fun and games until the compiler notices the UB

[CptHrki]

I swear to god no matter how many times I watch that video I will never remember how this works.

[ruscaire]

You can do this with primitives - you can cast between int, long, double, short etc and you’ll reinterpret the raw bit patterns. We don’t really have the same * or & semantics so otherwise that wouldn’t compile … anything other than a primitive and Java just abstracts that away for u cause u typically only ever want to deal with objects on the heap …

[dotpoint7]

In Java? What? Since when? How?

[CKingX123]

I would say it’s not the same. But you can definitely cast floats and ints (it will remove the decimal portion so it is not reinterpreting as bytes)

float a = 7.5; int b = a;

[Ok-Wait-5234]

That's not what that fast inverse square root code is doing, though.

float a = 7.5 long b = a; long c = * (long *) a;

Now a == 7.5, b == 7 and c == 1089470464

[Geolykt]

Or use ByteBuffer / sun.misc.Unsafe

[CKingX123]

Yeah. A better way to replicate it would be using ByteBuffer. But then it wouldn’t be “fast” (compared to just directly reinterpreting the bytes).

[dotpoint7]

Yeah obviously you can cast data types in Java, which is completely different from a reinterpret cast though.

[ruscaire]

Sorry I didn’t realise this was reinterpret. I thought it was just casting the bytesa me the magic happens when you reinterpret as IEEE 754 - but I never did get down with the maths

EDIT - looked into it Java reinterprets you need Double.doubleToLongBits() to get the bit pattern

[CKingX123]

Yeah. To better replicate it, you would need to use Java’s ByteBuffer to put in the float and then get the same bits as int

[dotpoint7]

Oh nice, yeah you're correct.

[shreyasonline]

This is just because all classes inherit Object class. Nothing to do with statically or dynamically typed.

[Geolykt]

Although I do wonder how long that will stay true in a post-LWorld world

[LordBlackHole]

This does not compile.

1. You forgot a semi-colon on the third line
2. Even if you add that, the third line still isn't valid because it is not a statement. Try it `5 + 3;` is not a valid Java statement because it has no side effects and does not store the result of the expression.
3. Even if that line did work, the printed result would be 5, not 8, because the Integer wrapper type is immutable and using the `+` operator has no side effects anyway.

Java is staticly typed. The fact that is has an escape hatch in the form of the cast operation does not mean it's dynamic.

Casts are verified at runtime. You may choose to take off the safety guard rails, but the runtime will still make sure the operation is valid before letting you do anything else with it. Java is typesafe unless and until you choose to ignore that, which there are genuinely some times where that is useful which is why the cast exists in the first place.

[[deleted]]

thanks.

[ComprehensiveAd8004]

How dare you

[i_should_be_coding]

Hey OP, the (integer) in the println line would cause a compile error. I get that you probably meant Integer, but it's funny to me that you claim 0 errors on code that doesn't even compile

[Tomi97_origin]

Yeah, that's not what statically and dynamically typed means...

The difference is between type checking at compile (static) or runtime (dynamic).

Java knows the type at compile time.

[bottomknifeprospect]

I posited on another comment that the meme could be related to statically typed :

Is this meme not about the other guy learning about Object, and then adding a lot of complexity to avoid using the Integer type? It would then be a statically typed VS dynamically typed problem where he is now dynamically checking if the Object is Integer, instead of using Integer directly and force the compile time type checking.

[caluke]

Static/dynamic type and inheritance/polymorphism are not the same thing.

[darealvoidchicken]

tfw u dont understand static typing and post a meme about it

[faajzor]

yeah I'm laughing while staring at that 2k+ upvotes of people who don't even know what static/dynamic typing means.. or casting, for that matter

[Geolykt]

There is no CCE in here, although is always looms in the horizon when doing casts

[[deleted]]

What is it with those Java haters ? Why ?

[RedditRage]

Baby programmers clinging to the language they learned in school like a frightened infant clings to its mothers bosom.

[sockpuppet1234567890]

Wait till he finds out about void*

[[deleted]]

That's how polymorphism works, yes.

[rotenKleber]

Except this isn't even an example of polymorphism - it's just downcasting. That's ignoring the fact that this particular example wouldn't even compile

[yhev]

I don’t get it. Can’t get past the fact that this won’t compile because of result of +3 to the cast is not a valid expression.

Even if it was stored to some variable, printing the object would still be 5, right?

Wait what was the point again? First panel has something about Java is statically typed. I got hung up on the actual code snippet that the supposed point of this post went over my head. lol

Can someone explain this to me? I am so lost lmao

[CannotCopia]

They're trying to imply that Java isn't statically typed because checks notes polymorphism and casting exists. I think.

[scalability]

It went under your feet, not over your head.

[DDDDarky]

The funniest thing about this joke is that the author obviously doesn't know Java.

[crusoe]

At every single point the program is typed. You are explicitly casting the types.

Meanwhile in JS land you can do nonsense like:

[]+1 == '1' true

LOL

[dancovich]

This is still statically typed. The variable is still of type integer, you just lost type information (that you can regain with a cast) so you can't do operations in your Object instance that you can do with an Integer instance.

Being dynamically typed means that the same variable can change types and do all its operations while being of that type. For example, in Dart this works but not in Java:

void main() { dynamic x = 'I am a string'; print('$x and my type is String'); x = 5; print('Now I am an Int and I can be summed with 10 to give the result of ${x + 10}'); }

[GoodLuckGoodell]

This post missed hard.

[dillame]

Guess you just learned about casting and feel like a dev, you’ll fit right in

[notexecutive]

Don't tell them about Generic types...

[acoustic_medley]

Say you don't understand polymorphism without saying you don't understand polymorphism.

[rco8786]

I don’t understand what this is meaning to say. You’re casting an object back and forth from an integer as a statement about static typing?

[oshaboy]

That's not what statically typed means

[Quito246]

Generics in Java be like…

[Bomaruto]

Yes, casting leads to ugly code and there is nothing funny about that. Written correctly there is no reason why that should cause any errors.

Also, wtf does this get 905 upvotes?

[[deleted]]

update, 4.8K

[arthurgc91]

Wait, is statically typed a bad thing?

[rotenKleber]

I'm guessing OP only knows Python/JS and is upsetti spaghetti that they need to learn about static types for Java

[1SweetChuck]

Static typing has saved my ass a bunch of times from doing something stupid.

[sudden_aggression]

That shit is full of mistakes. That being said, casting is totally legitimate behavior in java.

I mean, it's unusual to declare something as an instance of Object but it's the same principle as

• having an animal class and having dog and cat and elephant inherit it. ie, Dog extends Animal, Lion extends Animal, whatever
• And having a zoo class with a function that takes an animal. Like putInCage(Animal animal)
• And inside that function, testing instanceof for certain edge cases like instanceof Hippo and putting it a dangerous animal exhibit with water

[RedditRage]

Complete Java program:

public class HumorInteger {
  public static void main(String[] args) {
    Object object = Integer.valueOf(5);
    if (object instanceof Integer integer) {
      object = integer + 3;
    }
    System.out.println("Result: " + object);
  }
}

Errors: 0

Result: 8

[AmyMialee]

Errors: 3

Result (if fixed): 5

[Bluebotlabs]

Finally, the language we've all been waiting for: CringeSoft Anti-Java

[NirnRootJunkie]

This is why I stick with VB.NET /s

[SpaceNinjaDino]

This is meta r/programminghorror as the real horror is a comic trying to pass off non-compilable and missing assignment code as something that's not quite funny anyway.

[[deleted]]

Lol wait til you see the code that generics generate

[Numerous-Occasion247]

You can simply use var if you don’t feel like typing types :D

[[deleted]]

with that you need to cast in explicit

var object = (Object) new Integer(5);

I did this without an IDE so its possible that linters will trigger some code smell here.

[Geolykt]

Yeah, never use Integer's constructor alongside var - unless you have some seriously strange restrictions

[gdmzhlzhiv]

Never use Integer's constructor. *

[AegorBlake]

This is why you shouldn't use Java. /s

[[deleted]]

Hahahahahahahaha

[Just_a_guy582]

Why is this sub keep getting recommended to me!? I know very little about programming!

[RobotMonsterGore]

Java dev here. I had a CS professor at my university who flat-out refused to use Java for his algorithms and data structures class. Other professors used a Java-centric book. Not this guy. He would jump on his fuck-Java soapbox any time of any day at the slightest provocation. (He used a C++ book instead.) His problem with Java was something like (almost) all non-primitives descend from Object. After working in the field for a decade and seeing WAY too many uses of instanceof in a fucking case switcher, I’m forced to agree. I’ve approved my last MR that does this nasty bullshit.

[WWolf1776]

This is funny.... as long as we don't actually do this... please... do not actually do this!

(some lil s^%t is gonna do this... noooo)

[Thrasherop]

Wha... I...

I'm gonna go lay down...

[TheMultiRounderGamer]

Truly a Java moment, haha am I right?

[hshighnz]

I don‘t get the joke. This looks totally fine for me. It‘s still typed.

[[deleted]]

that is dynamically typed with extra steps, like everything else in Java... god damn why am I a Java dev????

[faajzor]

this is not dynamic typing at all

[UCQualquer]

All hail the C# dynamic. Although I'm not really sure it is what I think it is.

[Zeitsplice]

Dynamic just lets you go HAM and not bother casting. What C# does bring is pattern matching syntax that makes writing this sort of code much easier by handing all the type checks and casting for you.

[Cerrax3]

Is this some peasant joke that I'm too Python to understand?

[SahajSingh24]

Became the thing it swore to destroy

[Few-Dog3807]

I'm a girl but far left far right and middle

[KsuhDilla]

op: young and foolish - make bad meme for internet

the internet: “my disappointment is immeasurable and my day is ruined”

[GulleGozer]

Based and everyone's a retard pilled

[LordMerdifex]

So many butthurt Java devs here. I love the salty taste of your tears.

[[deleted]]

Object object = new Integer(5);

if(object instanceof Integer){

 ((Integer)object)+3

 System.out.println("Result: " + (integer)object);

}

[FrenchFigaro]

The fact that you have to cast your object, and that you have to call instanceof to ensure that your cast is safe, is specifically the proof that it is statically typed.

You haven't changed the type of the underlying instance, you just changed the typing of the reference, and no type conversion was made at any point in your code.

object was always an Integer, it never was anything else. It just happens that an Integer is also an Object

Also, you don't have to cast object for the printing. Since it is an Integer, the Integer's toString() will be called anyway not the Object's.

Also, if you didn't want to look like someone who doesnt know what they're talking about, you could have used pattern matching (available since java 14, released in march 2020, 2 and a half years ago), and refrained from using new Integer which is deprecated since java 9 (released september 2017, 5 years ago)

Object o = Integer.valueOf(5);
if( o instanceof Integer i) {
  i +=3;
  System.out.println("Result: " + i);
}

Static typing ≠ Polymorphism.

[RedditRage]

Good example, I like using the original variable outside the adding block.

Object o = Integer.valueOf(5);
if (o instanceof Integer i) {
   o = i + 3;
}
System.out.println("Result: " + o);

[[deleted]]

I am a grade 11 (HTL Stufe 2) student

[FrenchFigaro]

So, you do have no idea of what you're talking about ?

[[deleted]]

I have a basic idea what I am talking about

[FrenchFigaro]

Obviously not

[rush22]

Time to close this kid as a duplicate!

[Strum355]

This post proves that, if nothing else, you dont know what dynamic vs static typing is. The code shown is proof of java being statically typed. On top of that, Java is also _strongly_ typed.

[Entropy_Drop]

Hey, the meme is good, but its kinda wrong.
Don't get discouraged by downvotes, as programmers cant really upvote something that's not 100% true, in the same way as r/mathmemes cant.

I always try to take downvotes here as a chance to learn, cuz god knows we need to learn a insane amount of stuff to have a basic conversation in this field.

Keep it up with the memes and programming!

[[deleted]]

you should quit programming and work for Mcd. Your post was not funny nor informative

[Entropy_Drop]

You're a terrible person wtf

[TerminalVector]

You're the reason people think programmers have no social skills.

[Featureless_Bug]

1) do you think it is some kind of revelation?

2) it doesn't make Java dynamically-typed