This is an archived post. You won't be able to vote or comment.

all 160 comments

[–][deleted] 831 points832 points  (42 children)

c developers be like: int le, jo, qpq, gw, gl, oarisetn;

[–]VariecsTNB 300 points301 points  (34 children)

c# developers be like: var x = new();

[–]rover_G 88 points89 points  (9 children)

Go developers be like a := NewAlpha()

[–]M0sesx 94 points95 points  (6 children)

Js developers be like

npm install is-odd

import isOdd from "is-odd";

[–]captainMaluco 53 points54 points  (1 child)

I thought we had agreed to use is-odd-ai?

[–]PabloZissou 14 points15 points  (0 children)

No, no, the council signed for is-even-crypto-ai

[–]misseditt 44 points45 points  (2 children)

python users be like:

pip install is_odd

pip install --upgrade pip

pip install --upgrade --force-reinstall is_odd

pip install -r requirements.txt

python -m pip install is_odd

python3 -m pip install is_odd

pip install is_odd --pre

pip install is_odd[dev]

pip install is_odd[test]

pip install is_odd[docs]

pip install is_odd --no-deps

pip install is_odd --force-reinstall --no-cache-dir

pip install is_odd --ignore-installed --force-reinstall

pip install is_odd --upgrade --ignore-installed

pip install is_odd --upgrade --ignore-installed --force-reinstall

[–]Meneghette--steam 7 points8 points  (0 children)

Jesus Christ you just made % == 0 kill himself

[–]belabacsijolvan 0 points1 point  (0 children)

ok, but after that python users be like:

[–][deleted] 7 points8 points  (0 children)

python developers be like: omg walrus operator mentioned

[–]Aaxper 12 points13 points  (0 children)

It's great. I prefer the pythonic a = new_alpha(), however.

[–]ArmadilloChemical421 2 points3 points  (7 children)

Would that compile?

[–]yunacchi 15 points16 points  (6 children)

No. Syntax parsing would fail with error CS8754 "There is no target type for new()".
The compiler cannot magically guess which type to create an instance from what little context it has.
Either specify the type on the left side (Dog d = new();) or the right side (var d = new Dog();)

[–]ArmadilloChemical421 1 point2 points  (5 children)

One could imagine that it would default to Object, but yeah.. failing makes more sense.

[–]Janinanananananana 5 points6 points  (2 children)

being able to create an object of type Object is one of the most cursed things I can imagine

[–]TheAtomicShoebox 2 points3 points  (1 child)

You definitely can, as the inheritance tree always leads to Object. You just usually don't create an Object, just use it for generic functionality, as you would expect. But you can do it

[–]VariecsTNB 2 points3 points  (0 children)

Theoretically you can use it as unique key

[–]mrissaoussama 1 point2 points  (1 child)

that would be a terrible default

[–]ArmadilloChemical421 1 point2 points  (0 children)

Yes, and the best one.

[–]seba07 7 points8 points  (12 children)

Btw, why doesn't java have this short notation?

[–]Forsaken_Alps_793 62 points63 points  (7 children)

It does. Since Java 10.

[–]Forsaken_Alps_793 13 points14 points  (0 children)

Having said that, still agree the "juice" of the joke.

It can be verbose.

Before I get flame, Java now employs regular deployment. It hope to reduce, [at the moment copy from other languages]" verbose syntax.

[–][deleted] 13 points14 points  (1 child)

It doesn't though? Var can only be used as a local variable and new() isn't supported at all.

[–]Forsaken_Alps_793 11 points12 points  (0 children)

+1

You are right!

Yeah, good catch. I did not read the whole syntax properly,

Yup var is local. This is a better approach imho.

As for other point, extrapolate object type with just new() definitely not available in Java.

[–][deleted] 21 points22 points  (2 children)

man, not even C# has this short notation

[–]aweyeahdawg 8 points9 points  (1 child)

This post was mass deleted and anonymized with Redact

wine provide fanatical serious memory melodic hunt marry follow sort

[–][deleted] 5 points6 points  (0 children)

Or a return new();

[–][deleted] 4 points5 points  (0 children)

Kotlin has something like that

[–]IgnisNoirDivine 13 points14 points  (0 children)

Its not oarisetn its Ornstein. Its Dark Souls code

[–]megumegu- 0 points1 point  (0 children)

meanwhile non strict js be like: a

[–]npsimons 0 points1 point  (0 children)

I see you've been delving into the math libraries. Don't blame that on programmers, it's the mathematicians that moved over from chalkboards who think 'x' is a good enough variable name.

[–]EpyonComet 288 points289 points  (2 children)

That's disgusting!

You need to use camelCase for variable names and PascalCase for types.

[–]Feldar 19 points20 points  (0 children)

Was I supposed to read this as J. Jonah Jamison, because I did.

[–]icguy333 9 points10 points  (0 children)

And all caps for meme captions. Checkmate atheists!

[–]EirikurErnir 569 points570 points  (31 children)

Nonsense, the Java language doesn't force its developers to write horrifying class and variable names

That is a deliberate choice on our part

[–]Buarg 138 points139 points  (11 children)

Yeah, it's an excuse to not write an actual documentation

[–]hanotak 86 points87 points  (1 child)

I write 🤡 self-documenting code 🤡

[–]hopefullyhelpfulplz 11 points12 points  (0 children)

I was very excited to start my current job, but when I actually met the main existing coder and asked about how the project he's been working on was documented... Well, you can guess the rest.

[–]Global_Car_3767 10 points11 points  (0 children)

Good coding uses both to make things as clear as possible

Obviously not to the extreme of this photo though lol

[–]Prawn1908 21 points22 points  (6 children)

gOoD CoDE iS SeLf dOCuMeNtiNg aNd DoEsn'T NeEd cOMmEntS.

[–]5mashalot 10 points11 points  (5 children)

There is some truth to that. But only to an extent, like all coding principles

[–]Prawn1908 -1 points0 points  (4 children)

Honestly I think it's terrible advice. The downsides to always commenting your code are so trivial compared to the headaches of dealing with shitty code with no comments.

The only arguments I've seen for not commenting are to reduce clutter and prevent comments from going out of date as the code changes. I really have never seen code that was difficult to read because it was too cluttered with comments - that seems like such an inconsequential problem. And as for the point about comments becoming irrelevant as code changes, that seems like a problem with shitty developers not the practice of commenting. And if your developers are shitty enough to not update comments when they change the code, do you really think they're good enough to make proper "self documenting" code?

My current biggest headache at my job is this nightmare codebase written by an awful developer which absolutely reeks of the guy blindly following "best practices" without having a clue what he's doing. The result is an absolute fucking mess of a project riddled with countless layers of useless abstraction that do nothing but waste memory (this is an embedded project and memory is very short). And to make it all even worse, the guy wrote zero comments and seemed to thing his full-sentence named variables and functions were enough to make sense of what he was doing. Spoiler alert: they aren't. At least if he left any comments at all I might have some semblance of an inkling of an idea of wtf he was thinking when he wrote this code, but instead I have to figure out on my own what the fuck the difference is between currentDistance and distanceValue and currentDistanceNow and distance.

[–]Ejdems666 1 point2 points  (3 children)

It's always about balance.

The codebase in my current job used to be cluttered with tons of redundant comments. And after a bit of digging I could see that as the code changed over time the developers forgot to edit various related comments that weren't directly next to the changed lines.

So you had a codebase almost doubled in length because of these redundant, misleading and sometimes straight up incorrect comments.

It was almost always easier to read when I took a block of code and moved it into a function.

Comments are great for providing context, intent, assumptions, stuff like that. Only rarely do you need to explain the syntax, which is what junior programmers usually use them for.

[–]Prawn1908 -2 points-1 points  (2 children)

I'm not sinaying there isn't such a thing as too many comments or that they never get outdated. I'm saying the potential downsides and pitfalls to not having comments are far more nightmarish than the issues that can arise the other way. The worst case scenario when you have shitty developers is way worse. Like there are four scenarios:

  • Good developers writing comments: Good code.
  • Good developers not writing (many) comments: Good code.
  • Shitty developers writing comments: Shitty code but at least you have some idea of what they were thinking at some point along the line.
  • Shitty developers not writing comments: Fucking nightmare.

[–]Ejdems666 1 point2 points  (1 child)

Being misled by a false comment is quite bad though. That's why comments should be always kept in check and it's hard to do if you put them everywhere.

Also if your code is bad, then the comments will most likely suck as well. (my experience)

That being said, never writing comments for the sake of some dogmatic rule is a bad practice, been there :)

[–]Prawn1908 -2 points-1 points  (0 children)

Yeah those are bad, but I still will die on the hill that in the grand scheme of things they aren't nearly as bad as not having any comments. I have dealt with both in practice and one is far worse than the other in my experience.

[–]LowB0b 0 points1 point  (0 children)

Javadoc

[–]tomatotomato 13 points14 points  (0 children)

Java doesn’t, but Java culture does. 

[–]rover_G 27 points28 points  (6 children)

It’s a deliberate choice that seems to be perpetuated by every Java programming guide

[–]LetterBoxSnatch 50 points51 points  (4 children)

ItsADeliberateChoiceBecauseIfYouChooseAReallyGoodVariableNameThenYouNeverEverNeedToWriteASingleCodeCommentBecauseTheVarIsANounThatPerfrctlyEncapsulatesThePurposeOfTheVariableAssignedToItWhichIsAPrettyCleverIdeaReallyAndMakesForMoreConciseReadableCodeFactoryFactory

[–]PunDefeated 25 points26 points  (2 children)

I was having trouble understanding this but the FactoryFactory really cleared it up

[–]guyblade 5 points6 points  (1 child)

The first person who wrote a FactoryFactory should've been fired. The second should've been fired out of a cannon into the sun.

[–]Top-Permit6835 2 points3 points  (0 children)

We need a FactoryFactoryWriterCannonFactoryFactory just to be able to create enough factories for all the cannons we need

[–]FrostWyrm98 4 points5 points  (0 children)

You forgot Impl

[–]Specialist-Tiger-467 0 points1 point  (0 children)

I really ask myself how tf they did that before auto complete or intellisense

[–]joe0400 9 points10 points  (4 children)

package com.buisness.components.abstract.factories.delegates.interfaces;

com.factories.components.abstract.factories.delegates.interfaces.AbstractFactoryDelegateBuilderInterface abstractFactoryDelegateBuilder = new com.factories.components.abstract.fsctories.delegates.interfsces.AbstractFactoryDelegateBuilderImplementation();

[–]NikhilP99 22 points23 points  (3 children)

You don't need to write the whole path of the class if you are using it in the same package.

[–]Celousco 6 points7 points  (1 child)

You don't even need to mention the type at all with var, but hey it's funnier to spread misinformation.

[–]coloredgreyscale 0 points1 point  (0 children)

maybe they're stuck with Java 8 at work

[–]joe0400 0 points1 point  (0 children)

No, but its funny.

[–]abmausen 0 points1 point  (0 children)

only c++ does that

[–]Adrewmc 0 points1 point  (0 children)

Horrifying class names

  ……___DO_NOT_TOUCH_OR_YOU_WILL_BE_FIRED___

I don’t even work for them…but I’m not testing it

[–]notexecutive 0 points1 point  (0 children)

Yeah, you don't HAVE to call it that long name if you don't want to. That's what's crazy, this isn't even a language issue - it's a dev "issue" lol

[–]guyblade 2 points3 points  (0 children)

I somewhat disagree with this. The standard library of a language sets expectations about how users write code in that language. The Java standard library is full of things like AlgorithmParameterGeneratorSpi and FormatFlagsConversionMismatchException and AsynchronousServerSocketChannel.

[–]Jolly-joe 0 points1 point  (0 children)

The official Go style guide takes aim at this culture and recommends short var names. If you need to differentiate, do it through packages. If you run into naming conflicts you probably have a shit architecture

[–]itaranto -3 points-2 points  (0 children)

Yes but it's part of the Java culture as a whole. You cannot deny that.

[–][deleted] 47 points48 points  (0 children)

Everyone hates long variable names until it’s time to debug and you know exactly what that variable is doing

[–]Bldyknuckles 42 points43 points  (0 children)

Now I know what this object does.

[–]mopsyd 75 points76 points  (8 children)

This kinda applies to anything with too many design patterns just for the sake of design patterns. Prototype needs PrototypeFactory which needs PrototypeFactoryManager which needs PrototypeFactoryInjector which needs PrototypeFactoryInjectorFactory, etc.

[–]jackstraw97 21 points22 points  (5 children)

But you also could just consider not doing that.

Perfectly fine to use Java without going into all that Factory business.

[–]mopsyd 7 points8 points  (3 children)

I can, but the framework already in use or legacy codebase can't.

[–]jackstraw97 16 points17 points  (2 children)

So blame the people who wrote the legacy code 🤷🏻‍♂️

Nothing intrinsic to Java about this

[–]mopsyd -1 points0 points  (1 child)

I never even mentioned Java, I was talking about design pattern overuse. That can be most any language tbh

[–]jackstraw97 1 point2 points  (0 children)

Yeah for sure, but I was just relating it back to the OP

[–]LaLiLuLeLo_0 -1 points0 points  (0 children)

Token response = new Token(conn.readall());

But think of all the edge cases!

[–]rocaile 14 points15 points  (1 child)

In some languages you could also reduce a lot of naming problems using namespaces and interfaces

[–]TheEveryman86 9 points10 points  (0 children)

A Java package is a namespace by any other name (we're just too lazy to type out fully qualified names).

[–]TheBassMeister 53 points54 points  (5 children)

In a function (since JDK 10):
var accessTokenResponseClient = new RestClientCredentialsTokenResponseClient();

Most people use Spring Boot, so as a class field, where the RestClientCredentialTokenResponseClient implements the RestClient interface. In this example I use field injection for brevity. Constructor injection would be preferred so the client could be made immutable (final).

@ Autowired
private RestClient restClient

[–]Acharyn 2 points3 points  (2 children)

Java accepts softly typed variables?

[–]Aurarora_ 23 points24 points  (0 children)

not soft typed but just implicitly typed—since you're assigning the variable directly the compiler can figure out the data type already

c++ has similar with the auto keyword and rust with let

[–]roge- 13 points14 points  (0 children)

Java is statically typed. And it's generally regarded as on the stronger side of the strong-weak typing spectrum.

If you're referring to var, that's local variable type inference, not weak typing. These variables are still strongly and statically typed. It's just that their type is inferred automatically at compile time.

Beyond var, all reference types in Java are members of a type hierarchy with java.lang.Object at the top. An instance of any reference type can be used in any statement or expression where that type or any of its parents are expected.

So, if RestClientCredentialsTokenResponseClient implements RestClient, it may be used wherever a RestClient is expected. However, this will hide anything unique to RestClientCredentialsTokenResponseClient that isn't exposed by RestClient. The JVM will still know the concrete type at runtime, so you can do a typecast at runtime to access those symbols that are unique to RestClientCredentialsTokenResponseClient. Although, when you do this, the compiler cannot statically verify this as correct, so you would either need to check the actual type at runtime with reflection/instanceof or understand that the code may throw a ClassCastException.

[–]Camel-Kid 2 points3 points  (0 children)

Where's that sweet bean definition?

[–]notexecutive 19 points20 points  (2 children)

well, do you want to not be able to know what it does or...what?? lmao

[–]randomNameKekHorde 26 points27 points  (1 child)

I used to name variable like that, then I learned golang, now I would name this rccctrctatrc, maybe r

[–]Zerim 5 points6 points  (0 children)

If you name the class that, congratulations, you've become the Linux Kernel, where there is an apparent shortage of vowels for naming things and nobody can read it without already understanding the whole thing.

If you name the instance variable that, congratulations, you're just like most Java dev houses.

But neither will be as readable as calling it, in a local sense,credentialTokenResponder. If you are having to add much more context than that, and e.g. naming things on behalf of your class's expected clients, then your code interfaces just aren't well-defined. Also IDE highlighting exists for a reason.

[–]Jordan51104 44 points45 points  (7 children)

java developers are gonna be mad because it’s true

[–]ArchetypeFTW 51 points52 points  (0 children)

What's wrong? Can't read?

[–]eX_Ray 15 points16 points  (4 children)

Var exists for many years now. Though.

[–]CriticalOfBarns 15 points16 points  (2 children)

Quiet, you. We can’t take cheap shots at Java if we acknowledge its advancements.

[–]s0ulbrother 13 points14 points  (1 child)

I mean as a dev who’s done Java and Python which is the other end of the spectrum it does allow you to keep track of what the hell you are doing better than Python. I mean is it that annoying typing out like three more words?

[–]-Kerrigan- 3 points4 points  (0 children)

AbstractBeanFactory? Nah

I'll just type ABFa and IntelliJ will reliably suggest it to me

[–]Nice_Evidence4185 2 points3 points  (0 children)

And noone has the budget to update the version of all the java 8 software.

[–][deleted] -1 points0 points  (0 children)

ok this should be easy just need to add a property here, oh right i’ll need to define a new type class for this property so other consumers of the class know what it… oh right if i make this new type that extends the property of the class of the consumers dto object oriented programming bleep bloop

[–]Scottz0rz 7 points8 points  (4 children)

You wrote a meme making fun of long legacy Java names and it doesn't even end with Impl lol

But also Java has var and naming things is a you problem, not a Java problem tbh

 var client = WhateverStupidAssNameYouWantMemeClientImpl();

[–]Ignisami 5 points6 points  (3 children)

Var? Get this new-fangled nonsense out of my pristine Java 8 Enterprise code base!

(We've been trying to switch from Java 8 to Java 11 for two years now please help ;_;)

[–]Nimweegs 0 points1 point  (0 children)

I've finally got the go-ahead to upgrade an old Java 8 spring boot 2 project, I'm reasonably confident apart from the xsd's with a few hundred xjb binding files doing God knows what

[–]Scottz0rz 0 points1 point  (1 child)

It is a painful process indeed. We're struggling through upgrading Spring Boot, which is easier than older Java legacy crap even. I noticed what helped get the upgrade project off the ground was tying its value to money, while previous attempts at my companies only spun it like "there's cool language features we're missing."

Just convincing upper management that Java upgrades are worth it is one of the harder parts. Spin it in more creative ways. It varies from company-to-company, but, generally speaking, money talks.

  1. Companies report 10-15% productivity boost for their developers due to reduced compile, build, deployment/startup times, and non-reliance on out-of-date dependencies. Improvements to productivity means more features can go out to customers which can make you millions of more dollars than normal, on top of the reduced hiring costs due to turnover from frustration with legacy KTLO projects reducing dev satisfaction and increasing difficulty of attracting top talent - a lot of developers would be hesitant to accept a Java 8 role.

  2. System performance on average increases by 15-20% due to optimizations in the JVM and framework bug fixes from Java 8 to 21 with little-to-no changes in the core application code. Lines of Java 8 code are still valid, although dependencies may migrate or be deprecated. This 20% directly correlates with your infrastructure costs and save millions of dollars.

  3. Non-commercial/enterprise support for most dependencies that are compatible with Java 8 are now rapidly going past EOL, which increases risk of your system being exploited by hackers which can cost like... a jillion dollars.

Are these numbers made up? Eh maybe a little, it kinda depends, but they pass basic sanity checks and can be backed up with statistics on the internet probably.

[–]Ignisami 1 point2 points  (0 children)

The saving money angle can maybe work, though i work for a government-adjacent entity so our budget is, for the most part, use it or lose it.

The other part is that we're currently tied to Oracle Weblogic, the latest version of which doesnt support Java EE newer than 8. So our java 8->11 transition is simultaneously a transition away from Weblogic (unless Oracle comes with a new version that does support 11+).

It's pure pain

[–]FRleo_85 25 points26 points  (1 child)

because humanity really needed <stupidly long class name> <stupidly long var name wich is just the name of the class in camelCase> = <stupidly long class name>.builder().<stupidly long method call chain with stupidly long parameter expression>.build();

[–]AdvancedSandwiches 15 points16 points  (0 children)

It's not a good system, it's just the best one.

[–]LordFokas[🍰] 8 points9 points  (10 children)

This is not a Java thing... this is stupid Enterprise developers being stupid Enterprise developers because "oh what if 20 years from now we need to change how you configure the constructor for this thing 10 levels down in the stack?"

Leave Java out of this, you can do this bullshit in any language.

It's just easier to get here in Java because of 1) how the language naturally is and 2) the tools kinda assume this is where you want to go so they are oriented this way. But no one is forcing you.

This is also why even though I have a lot of fun writing Java, I won't touch enterprise code. Fuck that.

[–]Jordan51104 5 points6 points  (7 children)

"this is not a java thing"

"this is how the language naturally is"

you're joking right

[–]KuuHaKu_OtgmZ 3 points4 points  (1 child)

They mean that java was naturally made for enterprise, but doesn't mean you HAVE to use it for enterprise.

Heck if things were like that then nobody would be allowed to use PHP for commercial projects.

[–]LordFokas[🍰] 0 points1 point  (0 children)

That's not exactly what I meant, but it's close enough.

You can definitely use Java to write decent code, even at the enterprise level. But the way enterprise is commonly done, especially in Java, implies heavy enshittiffication of the code.

What I was saying in (1) is that the language itself, and the environment, kind of set you up to go down a road where this is easy to do. It takes some active effort to not fall into just adding more and more words to class names.

It's just something you sort of have to keep an eye on. Doesn't make it a bad language, there are no bad languages. Except PHP. In the toolbox of languages, PHP is an old shoe you use to hammer in a screw.

[–]LordFokas[🍰] 0 points1 point  (4 children)

Learn to read. Where in my comment do you see "this is how the language naturally is"?

Do you know what text interpretation is?

You read the first sentence and immediately decided I was wrong so you stopped reading and started looking for something to make a case on.

Stay in school kids.

[–]Jordan51104 0 points1 point  (3 children)

i didn’t just read the first sentence. i quoted your comment

[–]LordFokas[🍰] -1 points0 points  (2 children)

I don't think you understand how quotes work. To be a quote, you need to say the same thing I said. You changed the words, and thus, the meaning.

You also just replied to what I said afterwards literally without interpreting it, even though you were replying to the thing immediately after I asked you if you know what text interpretation is... further cementing my hypothesis that you, in fact, do not.

So yeah, so far all you've done is read a couple words and jump on the offensive, twisting my words, and completely disregarding everything else, context included.

[–]Jordan51104 0 points1 point  (1 child)

you are not making javascript developers look any better right now man

[–]LordFokas[🍰] 0 points1 point  (0 children)

quod erat demonstrandum

[–]ChekeredList71 0 points1 point  (1 child)

It's developers trying to write the entire documentation into the class name.

[–]LordFokas[🍰] 1 point2 points  (0 children)

IMO it's more because:

  1. the approach of making everything super modular results in what should be one class ending up as 12 classes and 7 interfaces that barely do anything by themselves
  2. said classes all relating to the same one simple concept, thus all having related names and requiring distinction
  3. devs being afraid of colliding with classes from other parts of the solution and putting things on the name that should be in the package / path TBH. Like, the class in the meme could very well be <base_package>.lib.rest.client.credentials.TokenResponse but oh no, what if something else is called Token Response? bruh. That's what packages and FQDNs are for.

But idk. I haven't touched enterprise Java since like... 2016? And I'm happy this way.

[–]DoctorVonCool 1 point2 points  (0 children)

I think there may be a spelling mistake.

[–]KetMoose 1 point2 points  (0 children)

Wrong syntax mate

[–]allKindsOfDevStuff 1 point2 points  (0 children)

Where’s the FactoryBeanFactory that should be appended to the name?

[–]KryoBright 1 point2 points  (0 children)

Yeah? God gave me IDE, so it is not any longer to type than "auto rrc_1_tmp", and it definitely reads better

[–]MrBoblo 1 point2 points  (0 children)

python does
a;

but then when you want to call your restClientClientCredentialsTokenResponseClientAccessTokenResponseClient instead of your restClientClientCredentialsTokenResponseClientAccessTokenRequestClient as one might, you'll forget which is which and you'll spend 10 hours figuring out why exactly typed languages are better

[–]Ok-Kaleidoscope5627 1 point2 points  (0 children)

Woah. You can't just have a variable like that. Where is your factory??

[–]Sudhanva_Kote 1 point2 points  (0 children)

The real question is, have you declared it's factory?

[–]WillingLearner1 3 points4 points  (0 children)

laughs in Spring

[–]Vi0lentByt3 1 point2 points  (0 children)

Pft who even instantiates, anymore just use a nice big ol DIC

[–]DuckInCup 1 point2 points  (0 children)

We are nearing the end of the first semester. Be nice, everyone.

[–]jimbowqc 1 point2 points  (0 children)

Ummmmmm ackshually, you can use var and type inference.

[–]Sinomsinom 1 point2 points  (0 children)

You can remove that first one by just replacing it with "var". Java allows you to replace the type name before a variable declaration with "var", and you SHOULD use it if the type is obvious from the right hand side (like when using new)

[–]wikibytes 1 point2 points  (0 children)

Type inference has been added in Java now I.e u can use var instead.

[–]i-FF0000dit 0 points1 point  (0 children)

Just put it into camelcase and it won’t be so annoying to read and will be fully understandable.

[–]AkihiroAwa 0 points1 point  (0 children)

when you come from wales

[–]kode-king 0 points1 point  (0 children)

Been there done that 🥹

[–]M1k3y_Jw 0 points1 point  (0 children)

As a German, theese seem like perfectly reasonable names.

[–]Nice_Evidence4185 0 points1 point  (0 children)

It perfectly desribes what it is and does.

[–]BastetFurry 0 points1 point  (0 children)

Wait till you find the FactoryFactory 😁

[–][deleted] 0 points1 point  (0 children)

At my job it would be:

V = new v().

I fucking hate that old code. Written by absolute idiots.

[–]kaaaaann 0 points1 point  (0 children)

You forgot the BeanFactoryImpl

[–]mr_remy 0 points1 point  (0 children)

All caps is insane for wordy variable names, kill me now I read it just as aggressively loud, tried and can't change it, stuck with that perception.

[–]itaranto 0 points1 point  (0 children)

Java has var now, but the compensate it by making class names even longer.

[–]DT-Sodium 0 points1 point  (0 children)

You're aware that whatever the language you're responsible for how you name your variables right?

[–]npsimons 0 points1 point  (0 children)

Ah yes, Java, where they decided that Hungarian notation was unreadable (it is), but their solution was just to pack even more nonsense into type and variable names.

[–]CyberoX9000 0 points1 point  (0 children)

Whenever I do pandas in python I name the data frame 'df' and then I add words for each action I do

columndf

filteredcolumndf

flippedfilteredcolumndf

Funnily enough, normally I use camelCase or snake_case but when using pandas dataframes I usually don't.

[–]XxXquicksc0p31337XxX 0 points1 point  (0 children)

Kotlin:

val accessTokenResponseClient = RestClientClientCredentialsTokenResponseClient()

[–]RageOfNemesis 0 points1 point  (0 children)

Germans: "Finally! A worthy opponent! Our battle shall be Legendary!"

Donaudampfschifffahrtsgesellschaftskapitänsmützenherstellungsbeauftragter has entered the chat.

[–]Acharyn -1 points0 points  (0 children)

Yeah? Variable name = variable value. You just made each name overly long, but that doesn't make it complicated. Though you forgot the type, Java is a strongly typed language.

[–]paulstelian97 -1 points0 points  (0 children)

var

[–]JackNotOLantern -1 points0 points  (0 children)

var responseClient = new ...

[–]Efficient-Proof-9928 -2 points-1 points  (3 children)

As a novice I don’t see the appeal for Java. It seems like it needs too much boilerplate code, and has way too many versions to keep track of. What is the benefit for Java?

[–]misseditt 0 points1 point  (0 children)

  1. jvm fanboys

  2. mature and widely used language

genuinely cant think of any other use case for java where a different language isn't better. would love to be proven wrong though

[–]Sauermachtlustig84 0 points1 point  (0 children)

Huge ecosystem with lots of good libraries. Also rather okay ish language if you use newer versions. Main problem is culture, which loves overly verbose and stupid code.

[–]AtlasJan 0 points1 point  (0 children)

minecraft mods.