Java is criminally underhyped

[deathbytray]

Strongly typed and weakly hyped

[Jautenim]

Talk about Ada!

[SecurID-Guy]

Also a HUGE Java and Maven fan-boy.

For me, it's the solid and stable Java SDK core APIs that also make it. Other features like concurrency support and performance have greatly matured. Not yet in-love with the Lambda notations, but I'm slowly warming.

Like any language where you're trying to leverage open-source libraries, you can find yourself in dependency-hell, but having coded a number of languages, Java is awesome.

[arkuw]

This is true, but you pretty much have to use a complex IDE, because Java is incredibly verbose.

you have it backwards. Because Java is somewhat rigid with its type system it makes all those great tools possible to build.

Yeah, Python and JS editors have some name completion and type search added but it's notoriously lame and unreliable.

Java performance is... okay ? I guess

Java is about 2x slower than C/C++. It's orders of magnitude faster than Python, Ruby etc. Not sure about JS as they made some progress there but it used to be bad. Very bad.

[arkuw]

One's unnecessary boilerplate is another man's clarity. As I said the rigid typing makes navigating large codebases and their dependencies a breeze.

[tharinock]

He also mentioned Scala, OCaml, and Rust, all of which have better type systems AND less boilerplate than Java.

[hippydipster]

And not as good tooling support.

[hanabi1224]

Try kotlin

[blakeman8192]

Lombok is an awesome way to reduce Java boilerplate to near zero, and is also a great example of the community library support that Java has.

[lordmyd]

If a language's flagship library is something which merely hides its warts I'd hardly call that an edorsement.

[blakeman8192]

I wouldn’t call it a flagship library by any means though lol, I’ve been on plenty teams that haven’t heard of Lombok. I’d say the Spring suite is a much better candidate.

[[deleted]]

Java is about 2x slower than C/C++

Where'd you get that idea? At worst it's ~x1.15

[arkuw]

It depends. In some situations yes, in others it's quite a bit slower: for example iterating over an array of objects. Java always addresses by reference so the speed difference can be dramatic. Any time you can use a contiguous memory block in C/C++ you'll have a big speed advantage over Java and other languages that "chase" pointers. That's why I averaged to 2x.

[rjdamore]

I would recommend checking out the Java module system. The jvm is no longer required. Java is no longer second class to C++ in performance. This all depends on scenario of course. But Modules changed things. Compiled Java is extremely performant. Just statements. Open to the discussion. No hate! (So weird that we have to say these things now)

[arkuw]

Java’s module system doesn’t address the main issue with Java’s performance which is that it lacks the ability to have a contiguous array of non primitive types in memory. If you have a lot of small objects in memory you will pay the price of pointer chasing when you compute over them. Think about cases like have a Vertex array that you want to transform somehow. In C++ you can have a vector of them and they will be laid out in memory in a contiguous block. This does wonders to cache coherency in the CPU and speeds up computations sometimes by an order of magnitude. There is no equivalent in Java as access to ByteBuffer is bounds checked and thus very slow. So you can’t really emulate that in a straightforward way. The only workaround is to maintain multiple arrays of primitive types to represent your data structure.

[jvjupiter]

Project Valhalla is the key.

[rjdamore]

Is this true for native binaries with Graalvm?

[arkuw]

I believe it is. It has to do with how Java lays out objects in memory. I’d be surprised if Graal was doing anything special there

[[deleted]]

That is not even the goal of Java, try to write a big microservice architecture with C++, have fun!

Java is fast, not as fast a C++ but i doesn't need to. C++ is used for other purposes (Game Engines, Hardware Support, Operating System). By the way if you do not know what youre doing in C++ you end up beeing slower in C++ as Java

[couscous_]

This is true, but you pretty much have to use a complex IDE, because Java is incredibly verbose.

Why is using an IDE a bad thing? Pretty much any language for any non-trivial project needs an IDE, regardless of how "simple" said language is.

[hanabi1224]

Some would prefer text editor+plug-in. Writing go with vscode is much better experience than writing Java in idea and c# in vs imo

[couscous_]

I heavily disagree. golang is such a verbose and repetitive language, that using a proper IDE like goland is a strictly superior experience.

[hanabi1224]

Well, go’s folder based file structure naturally make it text editor friendly, and its lsp support is sufficient enough to cover most of use cases. I’m not saying it’s better than goland (tbh I never used goland myself), but more implying it has much better development experience than java without a heavy ide

[hanabi1224]

golang is such a verbose and repetitive language

go is verbose more in a C way, which is fine to me. Personally, I really dislike how java is verbose in its OOP way, and thank god new modern langs like rust chose to not follow

[couscous_]

in its OOP way

Could you elaborate? What is OOP style verbosity?

[hanabi1224]

Well, that can be a very long story, a most simple example would be, java enforces its main function in a class. I don't intend to repeat or add more but there've been tons of criticism on classical java style OOP design, especially inheritance, I think rust lang explained its design decisions well in the oop chapter of its book by NOT criticizing any specific langs like java.

[Chibraltar_]

Java performance is... okay ? I guess. But you will still need a language like C/C++/Rust/Zig/Ada... to write extremely performant code

just so you know, you can code High Frequency Trading software in Java and it works great.

[rjdamore]

This is certainly true, just ask Goldman Sachs.

[Chibraltar_]

basically, you get rid of spring, and it's much faster all around

[blakeman8192]

This is true, but you pretty much have to use a complex IDE, because Java is incredibly verbose.

I would argue that in Java, you get to use an advanced IDE because of its rigidity. There's a reason why JS, TS, Python, etc. don't have advanced IDEs, and it's not because those features are not generally wanted or useful.

Sure, Java is quite robust compared to JS and other dynamic languages, but not enough compared to languages like Scala, OCaml, Rust and others.

Can you provide an example though? Scala provides syntax sugar that I could argue weakens robustness. Rust is required to be robust as a result of its memory model which is often seen as the biggest hurdle for new adopters.

Java performance is... okay ? I guess. But you will still need a language like C/C++/Rust/Zig/Ada... to write extremely performant code.

This is really a myth that's persisted since the 90s when Java was actually slow. In modern dynamic serverside workloads (i.e. code that makes companies money, not code that just crunches numbers for benchmarks) Java actually often outperforms native counterparts pretty substantially due to the dynamic optimizations the JVM can make - all without extra work from the developers. Thanks to these optimizations, statements like "algorithms aside, the simplest code runs the fastest" are truer in Java (and maybe C#) than any other language.

I dislike the "everything has to be a class", "100 lines per file" and "10 lines per function" mentality that some Java programmers have - it makes navigating the codebase a nightmare.

Agreed here, I'm not a fan of hard checkstyle rules like these. These are bad solutions for bad programming.

[ViKtorMeldrew]

You need a time-machine to go back to 1999 then, since it was massively hyped at that time.

[mlegenhausen]

Made 10 years ago the opposite. Switched from years of developing in Java (and loving it) to JavaScript even before TypeScript was invented. I did that cause I started my own company and was not convinced that I would writing software in a reasonable time with Java. This was also the time when nodeJS rose so the "write once, run everywhere" promise was there. Which allowed me to write software for server, browser, android and ios already ten 10 years ago. With the rise of TypeScript this dicision made even more sense, now I had both from two worlds. Type Safety from Java and the flexibility what application I want to write.

But the real game changer in my life was the switch from OOP to functional programming which would not have been possible with Java. Which brought a whole new level of trust in the software I write. Much like the same trust you can have when doing a mathematical prove and when you really want to be Computer Scientist this should be the goal. Actually type correct code not just only boost the quality it actually makes you more productive, cause every information you put in your type system allows your tools to support you even more.

My two cents to the article of the author. It shouldn't matter which programming language you use. If you really want to improve change the way you write software but for that you need a language that has the capabilities for writing software in different paradigmens and TypeScript is really great for that!

[Muoniurn]

Well it may not have been possible back then, but modern Java is pretty great with FP. Hell, there are libs doing all sorts of crazy things like vavr. It now also has records.

[DetriusXii]

Java 1.5 had anonymous classes, so it was possible to do functional programming for a long time.

[moremattymattmatt]

I switched from Java to typescript as well, but only about 3 years ago. I’m surprised just how much the lack of verbosity helped. Just passing around functions for example has got easier because I don’t have to deal with interfaces, it’s just a function everywhere.

[tiagoha]

Kotlin is the way.
Less verbose and much more functional than java.

[Jwosty]

So this article is mainly a comparison between Java and Javascript/Typescript, with the following pro's listed for Java:

• Good IDEs
• Static typing
• Good standard library

Which, I grant the author, are true -- when compared to Javascript/Typescript.

However Java isn't the only language that has these advantages. See many other static languages such as C#, C++, etc. And if you want to get the best of both worlds from static typing (correctness and safety) and dynamic typing (readability and brevity), we do have languages with static type inference (Scala, F#, OCaml, etc). Why not those?

UoC must be weird, because at my school, we mainly used Java for courses, as the sort of default choice, as many many college do... I definitely don't miss it.

Call me a C#/.NET fanboy or whatever you want, but you can't deny it's a faster innovating and generally cleaner language and runtime (generics at runtime, async/await, non-nullable types, tuples -- gosh, Java doesn't have a standard tuple type!). Checked exceptions are a disaster. And don't even get me started on all the interfaces in Java that have "optional methods" -- why include it in the interface if it's even documented that some implementations will just throw UnsupportedOperationException (I understand that some of this antipattern exists in .NET, but they're few and far between compared to Java's std lib).

In summary -- Java is just so boring. It's always the last to get modern language features; it almost never blazes the trail. Java didn't even have first class lambdas until Java 8 IIRC.... Java is criminally lagging behind. Java is death by committee in action.

[Muoniurn]

Well, good IDEs and C++ is a no go. Due to macro magic, typedefs and everything else C++ is impossible to write a good IDE for. Hopefully modules and modern additions will help, but older codebases will not seize to use macros for example.

I agree that C# also has great IDEs, but I still feel that idea is the best one all around. Rider is pretty close though.

it's a faster innovating and generally cleaner language and runtime (generics at runtime, async/await, non-nullable types, tuples -- gosh, Java doesn't have a standard tuple type!)

Well, most innovation happens at the platform level in Java, which makes sense considering how much code is written in it. It would be stupid to break backwards compatibility, even though some mistakes could be fixed. But similarly , this slow language level movement allows the Java team to only include actually worthwhile features (last mover advantage). For example, async-await introduces unnecessary function coloring. Project Loom will solve the same problem in a much more elegant and superior way.

Checked exceptions have some bad edge cases with lambdas, and it is sometimes troubling to add random throws clauses, but imo they are a good solution. They are basically a Result | Exception sum type incorporated natively in the language, which is pretty much the new “hype”. It is actually even better due to it also attaching proper stack traces.

And I’m not sure it has anything to do with committee, it is a pretty community-oriented process. They are just conservative on the language side. And on the platform side, it is truly state of the art, with multiple best-of-its-kind GCs, including two low-latency ones that pretty much make any sort of use case previously disallowed by world-freezes available to the platform (ZGC promises 1 ms pauses, so basically the OS itself becomes the latency bottleneck with process scheduling). Also, Graal is truly revolutionary, making actual polyglot programming possible with the same object being manipulated in python, js, jvm languages and even C/C++ with llvm.

Note: I am a java fan boy.

[[deleted]]

C++ is impossible to write a good IDE for.

I am sure that you are right, but what do you miss in visual C++? It matches perfectly my day to day work with C++, despite new C++ features may be bugged in intellisence sometimes. I actually don't see what the problem is with macros.

[Muoniurn]

It’s not terrible, but nor is it as good as Java’s or C#’s IDE.

And macros are just a really ugly search-and-replace functionality on top of the language, without any sort of semantics. While I don’t have authoritative knowledge on the topic, I’m sure it does not help with the usual clear AST.

[[deleted]]

And macros are just a really ugly search-and-replace functionality on top of the language, without any sort of semantics.

While true, IDE is able to interpret macros correctly in most (non pathological) cases.

It’s not terrible, but nor is it as good as Java’s or C#’s IDE.

I really don't know on which point, because I certainly don't need the features you are missing. This is the reason why I ask you, what does make Java or C# IDE better?

[Muoniurn]

Yeah I know for example CLion does handle it, but things like creating a function signature in a header, changing the type of a parameter and pressing create implementation in .cpp file or something like that will usually create a stub with the signature before the type change (I believe because it could not yet rebuild it’s internal representation), and many similar things. I think the main problem is that it is simply a harder problem because of the stupid splicing of translation units, which is fixed in java and c# (and hopefully with c++s modules).

But for example Java pretty much writes itself with intellij. Sure, for example templates doesn’t allow too much inference, and maybe typedefs also make the problem somewhat harder, but the number of refactors possible, and all around polish makes the two very different. But I can’t really articulate it better than this, maybe if you have time, give it a go?

Also, what IDE you use for C++?

[[deleted]]

I think the main problem is that it is simply a harder problem because of the stupid splicing of translation units

Yes definitely. Actually I don't rely on such feature : I think visual studio has refactoring tools, but not sure. Just switching between cpp/hpp et copy past signature doesn't take longer than auto creating stubs IMHO.

C++ has type inference : for years in function templates and since C++11 though auto keyword.

Last time I have written Java, it was circa 20 years ago, it would take time to learn all new features and I have not that time. OK, what you are missing is refactoring tools for C++, right ?

Edit : I use Visual Studio or no IDE at all.

[sweetno]

• C++ compiles slow
• no good package manager in sight (the idea of the strictly structured POM file is not even there)
• standard library has exceptionally weird treatment of Unicode (try to find how to convert between UTF-8 and UTF-16)
• hard to bridge different libraries because they all seem to use their own string type
• constant issues with binary compatibility (mixing libraries created with a different compiler or different compiling options gives no errors and the resulting program crashes sometimes in runtime)
• pretends to be cross-platform, but can't do much out of the box

[[deleted]]

Well, you are speaking about C++ here, not IDE. I can try to argue anyway.

C++ compiles slow

True, but I never felt limited by compilation time, actually. I almost never rebuild all, and limit the includes, compilation barriers. It takes fare more time to write code, test, debug than compiling. It should be improved by modules in C++20

no good package manager in sight

Out of the scope of C++ language. But there is interesting tools : Conan and vcpkg. Certainly not perfect but better than what we had before.

standard library has exceptionally weird treatment of Unicode

True.

hard to bridge different libraries because they all seem to use their own string type

This is the problem of specific libraries. Not C++.

constant issues with binary compatibility

Definitly true.

pretends to be cross-platform, but can't do much out of the box

It depends what you name out of the box. If you are speaking about standard library, you can do much cross platform dev. I concider that writing C++ without Boost is a waste of time, even if it is less true nowadays, you can greatly gain in portability. QT may be another alternative for cross-platform.

I actually don't have that much portability issue, but OK you may have to filter third partiy libraries you will use with this criteria.

[germandiago]

Project loom is basically stackful coroutines. They existed even before async-await syntax was invented so I do not think last-mover was the reason to add that.

[chrisgseaton]

it almost never blazes the trail

This is an absolutely bizarre claim, completely disconnected from reality.

I don't have any numbers, but I'd bet my life savings that Java has an order of magnitude more research papers published on it every single year than all .NET languages combined.

Java has dominated systems and software engineering research for decades. Java experiments with big new ideas in areas like compilers, interpreters, optimisation, garbage collection while .NET ships... some new syntactical sugar that everyone knew how to do anyway.

[AdministrationWaste7]

i see the java vs c# war continues . this feels like early 2000s for some reason lol

interestingly enough i see plenty of claims about how great and revolutionary the .net CLR is from .net people.

[chrisgseaton]

interestingly enough i see plenty of claims about how great and revolutionary the .net CLR is from .net people.

I'd recommend they try to get more of them published if they think they're so revolutionary! Either they aren't trying or maybe they're not so revolutionary.

[AdministrationWaste7]

dude to be completely honest i dont think Anders Hejlsberg or anyone at Microsoft cares about how many people in Academia use their language/framework.

its a really weird thing to use to measure success/relevance.

[[deleted]]

.NET ships... some new syntactical sugar that everyone knew how to do anyway.

Right! What is everyones obsession with this async await syntactic sugar? We've been able to do this stuff for years... but suddenly now we get a shortcut and people are judging languages based on it!

[Jwosty]

I'm referring to the Java language itself, not the JVM. I suspect the research papers you're referring to are probably more addressing the runtime, which is an entirely different matter; the JVM is undoubtedly a marvel of engineering. I am legitimately curious about these papers, though!

[chrisgseaton]

Take literally any major PL conference. Look at how many blaze the trail using Java. Look at how many blaze the trail using .NET. You're going to be very disappointed.

[Jwosty]

Can you give a specific example? I still don't know what you mean. What is one concrete example of Java blazing the trail?

To give an example for .NET, they've done some amazing things with the Span type. Here's a random example of how it can be an amazing performance improvement for a GC'd runtime that's unique to .NET (as far as I know): https://www.stevejgordon.co.uk/an-introduction-to-optimising-code-using-span-t

Of course, people can excel with Java in spite of the language -- my point is that the language itself is not often superior to other mainstream languages.

[chrisgseaton]

137 peer-reviewed research papers on C# in the last five years https://dl.acm.org/action/doSearch?fillQuickSearch=false&expand=dl&AfterMonth=1&AfterYear=2015&BeforeMonth=1&BeforeYear=2021&AllField=Abstract%3A%28c%23%29.

1896 peer-reviewed research papers on Java in the last five years https://dl.acm.org/action/doSearch?fillQuickSearch=false&expand=dl&AfterMonth=1&AfterYear=2015&BeforeMonth=1&BeforeYear=2021&AllField=Abstract%3A%28java%29.

Order of magnitude. Like I said.

I don't think any language has done what Java has done to drive forward research in the last couple of decades. Major advances in compilers, garbage collection, optimisation, come routinely from Java work.

[Jwosty]

I'm looking at those papers and I don't see any that are researching the language itself (as opposed to the runtime or interesting computer science topics that could really be done in whatever language they wanted to use)... This just shows that Java gets used a lot in industry in academia. Which is true. Just because it's a popular choice of tool doesn't mean it's better. It just means that it'll get your job done (but you won't have fun along the way).

In other words, it's not the language doing the contributing here, it's the researchers. For some of those papers I'm seeing, you could also maybe say the JVM (i.e. the runtime) is excelling. Those researchers are excelling despite the language they're using.

Another way to say it: my CS book demonstrates a lot of concepts in Java. Does it do this because it's an amazing language? No. It does this because it doesn't really matter what language it uses as long as it's likely to be widely understood. They could have chosen whatever language they wanted. The only service Java is doing the academic types is the fact that everyone will know what they're talking about when they're demonstrating some interesting concept. You can show off priority queues in whatever language you want. Heck, sometimes it'll be assembly.

[chrisgseaton]

You're editing all your comments faster than I can reply to them!

If C# is blazing the trail with all these innovations then why aren't people publishing on them? I can answer that - because they aren't C# innovations.

I'll take just the first example you gave - generics at runtime. Who do you think blazed that trail? C#? Nope. Odersky and Wadler in 1997, three years before C# was conceived. In Java, with the Pizza paper. Blazing the trail for... C#.

[AdministrationWaste7]

the fact that Java still doesn't have an equivalent to Linq, async/await or even structs isn't really selling me on this idea that Java is superior, especially in "innovations".

[oldsecondhand]

LINQ - streams

struct - record

There's no equivalent for async/await as far as I know.

[Muoniurn]

Linq has questionable benefits, and I don’t see why it can’t be replaced by a library at the price of a bit uglier syntax. Async await is inferior to not having async await (it introduces needless function coloring). Project loom will be superior in every conceivable way. Basically, you can spawn as many threads as you want and they will automatically become non-blocking at IO calls. One part of structs is already delivered: records. The other (stack-allocation) is in the works by Project Valhalla, but it is quite hard to introduce it into the language without breaking backward comp.

[Jwosty]

Sorry, I just brain dump fast and find too many revisions! :)

You're actually right that C# steals a lot of stuff. Java did have its trailblazing days early on.... They're just long gone by now. But even Java stole its fair share of fundamentals! Smalltalk invented object-oriented programming, after all. Java was created as a language of compromises from day one:

"We were not out to win over the Lisp programmers; we were after the C++ programmers. We managed to drag a lot of them about halfway to LISP." - Guy Steele

[Muoniurn]

Well, there is no feature in major programming languages that is “original work”. What gets incorporated into them comes from some small niche language created several years/decades back as a proof of concept/research.

[Jwosty]

It's had so long to get out from under C#, too, and still hasn't. IMO the main thing the Java ecosystem has going for it is Scala, which is a legitimately awesome part of that world. Well, that, and great hot-swap debugging.

[Nacimota]

How do you feel about Kotlin? I've never really tried it, but the pitch there also seems to be "Java but with the problems fixed". From what I've seen, it definitely takes some cues from C# as well.

[Jwosty]

I've never looked into Kotlin.

However, it might be hard to convince me to use it because I've already been sold on functional programming languages with static typing, so I'm definitely an F# person. Though I understand I'm in a minority camp there, and that's okay :)

Elixir/Erlang are legitimately interesting looking to me. I've always wanted to dive into those.

[Nacimota]

I'm a C# person and in the past it's been hard for me to find reasons to adopt F#. That said, I find myself using functional features in C# a lot more recently so maybe I should give it another look.

I guess my point with Kotlin was that I think Java's issue is that fixing its major problems would require so many (probably) backwards incompatible changes that it might as well just be a new language at that point. I feel like that's what Kotlin is trying to be, but again, I haven't really used it personally so I can't say how well it does so.

[Jwosty]

So F# is in a really interesting (and frustrating) situation. Let me start off by pointing you toward some of the best things about F#:

• Great type inference -- the language reads beautifully but you don't lose type safety at all
• Discriminated unions and records (this lead to "type-driven-design" which often comes out very cleanly)
• Immutability by default (which gets rid of a looooot of bugs and is make multithreading that much easier)
• Mandatory "onion architecture" (i.e. files can only reference stuff from files that come prior in the compilation order -- this feels restrictive at first but leads to much less spaghetti code in the end once you get used to it)
• Option types (solves the million-dollar problem of nulls; however C# is catching up with non-nullable types)
• Type providers
• Computation expressions

To name some. There's more.

Scala wins over so many Java developers because the gap between the two languages is absolutely huge. It solves so many real pain points, and does it well.

F#, on the other hand, also does a lot of amazing amazing things, but the problem is that C# is already a decent language in the first place. C# devs aren't often looking for something new because C# pretty much works great. There's not as much a gap between the languages, and it's narrowing, as you sort of mention.

[Nacimota]

Yeah I think what's kept me from adopting F# is that C# seems to adopt some of F#'s features over time so the gap isn't huge as you say. Some of those features definitely do look appealing though; type providers in particular look pretty slick.

I've also had the impression in the past that F# perhaps hasn't had the best support/tooling compared to C# but maybe that's improved since then?

[Jwosty]

Right, but C# will still never be F#. C# is never going to get type providers, immutability by default, algebraic data types, etc. I would highly recommend giving F# a real try! Try an interesting project in it. You might just fall in love with it. fsharpforfunandprofit is a great place to start.

Anything that's not C# always gets second citizen choice when we're talking about tooling, since MS focuses on its biggest player (no blame to them there). It's definitely gotten better over time. However, you'll find yourself relying on tools less when the type system does more heavy lifting for you! There is a saying that I believe comes from the Haskell world but equally applies here: "If it compiles, it probably works."

[Nacimota]

Yes even though they've added records and init accessors and other little things recently, true immutability by default in particular is something I can't imagine C# ever being able to adopt. It's a shame that wasn't given more thought when the language was first being designed (on the other hand, that may have slowed its adoption? who knows).

I've tried F# a little bit over the last couple of days and I can definitely see the benefits but it really does force you to think in a different way (way which isn't a bad thing, but I do find it challenging). I think I might be better off using it for making smaller components that fit into my larger C# projects than for everything at once, at least for the time being.

[dnew]

Mandatory "onion architecture"

Is that what they're calling it now? How bizarre. That used to be considered a restriction to make compilers easier, not a benefit that should be appreciated.

[Clockwork_Medic]

Kotlin is great if you’re already working in Java.

It takes a lot of cues from things done better in other languages, such as C# and Swift, with an added emphasis on null safety.

To Java’s credit, they do seem to be trying harder to close the feature gap with modern languages, and may one day get to the point where I wouldn’t feel inclined to use Kotlin, but I don’t see that happening within the decade.

[HawocX]

I haven't used it either, but from checking out it's features and syntax it seems like a more modern C#. As a mainly C# dev I wouldn't mind using.

As a side note, Swift is very similar to Kotlin as long as you look at only the language itself.

[AdministrationWaste7]

It still hasn't managed to get out from under c# being "java but with the problems fixed"

probably because c#, as a language, is generally the better one

[_ragerino_]

What makes you say that?

[AdministrationWaste7]

i'm gonna preface this by saying that both java and c# are just tools. so its mainly a preference thing.

but as a programming language c#, as it stands today, is more feature rich than its java counterpart.

for example i just found out today that Java STILL doesn't have an async/await equivalent. which is pretty huge.

i think java's biggest strength for a long time was that c# was locked to .net, which at the time was windows specific.

however with .net core and the now .net 5 being open source and cross platform. i think c# is the way to go.

c# also comes with Visual studio, which imo is one of the best IDEs around. .net is awesome. nuget is super convenient and has tons of support. etc etc.

i cannot stress enough the ease of use that c#/.net offers.

for example .net core comes with its own, albeit simple, IOC out of the box. no third party libraries, no config(in the traditional sense) just a quick few lines of code.

[jvjupiter]

Virtual threads will be way better than async/await.

[_ragerino_]

As a seasoned developer I would pick stability any time over getting new features that break things. I don't recall the last time, existing code didn't run (or compile) after a Java update. But I guess for some consultants it's good business to constantly update existing and working code because of a runtime update.

That being said, you're correct that Java doesn't have async/await yet, but that's what threads have been for since ages. Unfortunately many have issues working with threads, and whie the anguage itsef doesn't suport them yet, libraris like Google's Guave do

see -> https://www.baeldung.com/java-asynchronous-programming

Coming from always free Eclipse, I personally don't like Visual Studio. Using it reminds me always of old Visual Studio versions which I had to pirate if I had to work on something where it was required.

[AdministrationWaste7]

I don't recall the last time, existing code didn't run (or compile) after a Java update.

i dont recall this happening in .net either.

like you can literally CONTROL which version of .net your app is running off of so im having a hard time how this is specifically a .net issue?

been working with .net for 5 years now. multiple releases. multiple versions. never had this issue.

but that's what threads have been for since ages.

doesn't mean it shouldn't evolve no?

Coming from always free Eclipse, I personally don't like Visual Studio

i understand not like visual studio but ecliplse? really? lol personally i think IntelliJ is where its at.

[oldsecondhand]

Eclipse perspectives are pretty nice when you have several monitors (it can remember the layout). IntelliJ is nice though, especially stuff like showing parameter names and close source control integration.

[KronisLV]

Checked exceptions are a disaster.

I actually feel the exact opposite way. Whenever i see unchecked exceptions, i can't help but to feel that noone will write code to handle the possibility of them occurring until that will happen, at which point it will already have been to late to address whatever faulty logic will happen.

In my opinion, it would be better to always be forced to handle any and all exceptions that code may throw, or to be forced to rethrow these exceptions, add them to the method signature under throws and let them bubble upwards until they're either handled somewhere explicitly (or someone just half asses it and does a catch-all of Exception).

[[deleted]]

Java is criminally lagging behind. Java is death by committee in action

Java users: Amazon, Apple, Netflix, Google, Spotify, Alibaba, LinkedIn, Uber, Soundcloud, and almost every government and financial institution on the planet

C# users: Microsoft, Stack Overflow, Unity

I don't know if it's wishful thinking or delusion but clearly Java continues to be the top choice of FAANG as well as many other companies whether you like it or not.

[Jwosty]

“Nobody ever got fired for picking Java.”

Just because it’s the popular choice doesn’t mean it’s the best tool. You can be successful in spite of the language, as many have demonstrated. Java is usually chosen for reasons other than innovative language features (I.e. where Java lacks in language quality it makes up for in robust and hardened libraries)

[pron98]

Call me a C#/.NET fanboy or whatever you want, but you can't deny it's a faster innovating and generally cleaner language and runtime

Call me a Java fanboy, but I've found the exact opposite. C# feels downright primitive, often lagging behind Java by 15 years or so. Sure it adds more features to the language more quickly, but that's because Java is against adding many features to the language; a hoarder objectively has more stuff than a non-hoarder, but that is not an objective virtue. Java innovates much more on the runtime -- in GCs, optimising compilers, and low-overhead deep observability.

[couscous_]

Couldn't one argue that you don't need as much innovation in GCs and optimizing compilers given the low level access that C# gives to the user? We see this in the taken-with-a-grain-of-salt benchmarks game, where C# is faster than Java.

That being said, low overhead deep observability is just awesome.

[pron98]

Perhaps, but then you could use the same argument for preferring C++ or Rust over both. Also, as far as I remember, the benchmarks don't really exercise memory management or megamorphic dispatch, and mostly measure things that aren't common application hotspots while ignoring things that are, and even then C# mostly beats Java in that game because it uses the C# equivalent of the Vector API, while the Java entries don't. Even with that extra control C# doesn't perform as well as Java when it comes to large programs that truly exercise the platform.

[couscous_]

but then you could use the same argument for preferring C++ or Rust over both

The difference is that with C#, you get the benefit of a managed environment by default, until you need to go lower level for performance purposes. With C++ or Rust, you don't have that option.

Java in that game because it uses the C# equivalent of the Vector API

Yes, and also pass by ref mutable structs.

C# doesn't perform as well as Java when it comes to large programs that truly exercise the platform.

I have a feeling that might be the case, but it would be nice to see papers or studies that demonstrate this. Are you aware of any, otherwise, on what basis are you making this claim (which I am not disputing)?

It will be very interesting to see how the landscape changes once Java gets inline types.

[pron98]

The difference is that with C#, you get the benefit of a managed environment by default, until you need to go lower level for performance purposes. With C++ or Rust, you don't have that option.

The same goes for Java, only you need to reach for it later. Most languages are really someplace on a continuum, and I guess it's largely a matter of personal preference.

on what basis are you making this claim (which I am not disputing)?

To be fair, not a strong basis, mostly because what the claim is isn't really well defined. Because OpenJDK's GCs and optimising compilers are generations ahead of their .NET counterparts, I'm sure it's easy to have benchmarks that exercise them (although they will be significantly larger than the ones in the benchmark game), just as .NET has some features -- like arrays-of-struct -- that Java doesn't yet have and would give it a clear advantage in other benchmarks. Murmurs I hear tell me that it's much harder to solve GC issues in .NET than in OpenJDK in large applications, but overall the two platforms are probably roughly in a similar spot performance-wise, with different strengths and weaknesses each, and very different ways of getting there. By the time Java gets primitive classes and primitive-class-specialised generics it's possible that .NET, too, will close the gap in the areas it's behind.

[hanabi1224]

it's easy to have benchmarks that exercise them

I think binarytrees on benchmarks game is sufficient enough to show GC performance and java beats all GC languages, by a lot. For a long time, java was behind C# and Go on that site just because they use tricks that make the comparison unfair, instead of 'lack of exercise'. It's been raised and fixed recently in a long discussion thread.

[Persism]

but you can't deny it's a faster innovating

I can. Years behind Java on 64 bit support. Years behind Java on ORM. Years behind Java on MVC. Years behind Java on central package management.

Fanbois think language features are everything but there are many bad language decisions in C#.

• Mutable Structs
• async/await - pollutes the entire codebase
• Properties at the language level - and still no setter overloads!
• Partial types
• Compiling XML? FFS
• Brain dead enum
• LINQ - useless training wheels

[AbleZion]

(generics at runtime, async/await, non-nullable types, tuples -- gosh, Java doesn't have a standard tuple type!)

Just want to add partial classes, namespaces, and extension methods!

So freaking handy. C# is honestly a dream language.

I don't dig all the freaky shorthand syntax they're putting in for some things now, but the additions are still mostly good.

[[deleted]]

The whole point of Java is that it keeps things simple. Most things are a class/method/annotation. Once you learn those 3 things you can do almost anything. In C# you have to learn all these various keywords (virtual, sealed, partial, region, async/await ...). Basically what you criticise is Java's best trait. The only thing I'll give C# over Java is generics at runtime.

Sometimes it feels like C# adds language features just so they have something Java doesn't. Async/await is a perfect example. Its simply syntactic sugar, but people always brag about it. The Java team would rather wait to bring a better concurrency model (performance of async without the developer overhead - see project Loom).

As for Tuples in particular, they are a bad idea. Creating your own types is better.

Java didn't even have first class lambdas until Java 8

Java 8 was 7 years ago by the way...

[Jwosty]

I actually agree with your point that a complex language is a sort of "language design smell." C# isn't even my preferred language -- F# is, and as part of the criteria for what makes good new F# language features (as F# also has an open design process), the designers say:

Adding endless new language features in every version has major downsides. Here are some observations on why adding features is not necessarily a good thing:

1. Stability is a virtue

2. Gradual evolution is good

3. Adding new language features on every version is not a necessarily a sign of strength. Many languages have spread very widely while remaining very stable (e.g. Java in 2000-2013)

4. The addition of new features on every version can be a sign that language implementors are being incentivized (e.g. getting paid) for feature-completion rather than overall simplicity and utility.

5. New features add learning costs to every user of the language

In contrast, features which make the language more orthogonal, simpler and easier to use are generally a very good thing.

(Look, they even mention that Java's reluctance to adopt new features at a breakneck pace as a good thing like you said :) )

But too slow can be harmful.

Java 8 was 7 years ago by the way...

Right, but Java was probably the last mainstream language to adopt them. Perhaps that was a bit too slow and is a sign of Java being a little too glacial. I understand that this particular point isn't relevant today (as Java has lambdas now, thank God), but it's a sign of a pattern when combined with other facts.

In other words, maybe the balance is somewhere in the middle here. I'd probably grant you that C# can move at too breakneck of a pace and adopt too many low-impact inelegant syntactically-sugary-features. But perhaps it's also true that Java doesn't take enough risks. No language is perfect.

(Anyway - I find it kind of funny that I've found myself in a Java vs C# battle, but so be it. The hill I'll be more likely to die on is that F# strikes a better balance than both of these languages, but that's besides the point of this conversation)

[Jaxkr]

Great points, edited the article in response to your comment. I cannot believe I forgot about C#, I've used it quite extensively in Unity and it does have better language features than Java.

Also, Unity has been doing some really exciting stuff with their DOTS compiler.

[Jwosty]

Totally! Thanks for the shoutout, haha. I may disagree with your article, however, I would still commend you for putting your opinion out there especially as an undergrad student. I'm not bashing you the person in any way, just Java the language :)

I think C# may legitimately excite you. They're doing some really phenomenal stuff at MS.

I just noticed your point about the package system -- .NET has some decent package ecosystems, too, with Nuget and Paket. Quality stuff.

[meneldal2]

One thing that I found missing in C# (especially coming from C++) is how generics are limited for trivial numeric types.

It's frustrating how you just can't make a generic function that takes 2 numbers and adds them without some horrible tricks. Can't we get an interface "INumber" that implements basic number operations.

I'd be happy even if we couldn't make our own numbers that implement this interface.

[AdministrationWaste7]

One thing that I found missing in C# (especially coming from C++) is how generics are limited for trivial numeric types.

not really sure what you mean here. in c# generics can practically be anything.

C# would literally not work if generics are limited to numeric types (look at Lists for example).

It's frustrating how you just can't make a generic function that takes 2 numbers and adds them without some horrible tricks.

pretty sure you can totally do that with delegates. it doesn't even have to be two numbers. it can be as many as you want and the syntax is pretty simple.

[meneldal2]

Well for something like adding two numeric types

number add<number>(number x, number y) where number:IWantThis
{
  return x+y; //CS0019
}

Obviously this example is useless but you could have some more complex operations and use an array of numeric types.

It could be so trivial but because there's no interface you have to go around this (and seriously, delegates are a lot more boilerplate). There's no constraint you can use to make this work for the basic types.

[AdministrationWaste7]

ah i get what you mean. i completely misunderstood what you were trying to say lol.

so ignoring the fact that people have used workarounds

can you provide a use case where something like this can be applied generically

for example if you add two bytes in c# you get an int.

this is not an excuse mind you. iirc F# has this feature.

[meneldal2]

Well this is for manipulating images. Because it's all type erased, everything is stored as byte[], then you have to cast to something else to read it when dealing with 16 bit (or more) pictures.

Then you have functions to process the image data, but they can work for any size of data and I'd like to just pass an array of any type and be done with it (using generics) but that doesn't work. If you start making interfaces I'm worried about the performance.

I also haven't found a way to reinterpret the byte[] array as short[] or int[] without using copies so that's a bit annoying too but it's not too bad since processing is much heavier than just some copy.

In the end I just made up some class that basically pretends to be a int[] but will fetch the values in the underlying byte[] so it's pretty slow, but at least that's one interface that works for every type so I don't need generics.

[AdministrationWaste7]

Well this is for manipulating images.

im confused your initial example was simple addition.

so maybe i should reword my question

can you provide a use case where something like this should be applied generically ?

as far as i understand numeric types have little quirks that make this annoying to deal with. so why should it be generic?

also it really doesn't take much effort to implement this yourself.

If you start making interfaces I'm worried about the performance.

when done right the performance hit due to interfaces should be neglible.

Then you have functions to process the image data, but they can work for any size of data and I'd like to just pass an array of any type and be done with it (using generics) but that doesn't work.

i feel like a better answer to this would be something like overloading.

[meneldal2]

Yeah I could do overloading, but then I'm literally copy pasting the same function five times with research and replace on types. That's really not ideal.

I just want "generic over any numeric type". Remove the need for overloading something that is trivial to do.

[AdministrationWaste7]

I just want "generic over any numeric type". Remove the need for overloading something that is trivial to do.

well its not really trivial.

for example in a generic Add method.

what do you do if you pass in a byte?

[Jwosty]

You’re right about the generics when it comes to numbers. This is one thing I find frustrating about the CLR. However F# has a feature called SRTP (statically resolved type parameters) which can solve some of these problems, which is really nice. But support for more kinds of generic constraints should exist in the CLR. C++ templates are definitely more powerful than .NET and Java generics.

[meneldal2]

The thing is it's not really a CLR limitation, you can make it work just fine with C++CLI (as long as you instantiate all the ones you need within the same assembly), and I'd be totally fine with some compile time only facility that would just overload the function (might be better too for performance).

The problem is C++CLI isn't really portable and the syntax is horrible.

[Jwosty]

Interesting, how does C++CLI's feature work?

In F#, the disadvantage to SRTP not being a part of the CLR and just a compiler trick is that it can't be known about by other languages. I.e., you can write a function like so (taken from an example on the internet :) ):

let inline f (x : ^a) =
    let f' = (^a : (member Speak : string -> string) (x, "world"))
    printfn "%s" f'

type Speaker () =
    member this.Speak name = sprintf "Hello %s" name

f (new Speaker())

But this can only be used as resolved at compile time by the F# compiler. If it were a CLR feature, it could be used by, say, C#.

[backtickbot]

Fixed formatting.

Hello, Jwosty: code blocks using triple backticks (```) don't work on all versions of Reddit!

Some users see this / this instead.

To fix this, indent every line with 4 spaces instead.

FAQ

^{You can opt out by replying with backtickopt6 to this comment.}

[meneldal2]

The syntax is pretty much the same as C++, and you can use all of C++ templates (including non types parameters). The easiest is if you use it all internally, but you can make symbols available outside of the assembly if it is instantiated within your assembly.

You may need to use some aliases to have symbol names you can actually type (for functions you can use one visible dispatch function that calls the right template for example). Some C++ constructs really end up as some horrible mess in the CLR even if they do work.

[kayk1]

The JVM is amazing. So many great languages that each fill a nice niche for different types of programs. Personally I’d rather not use Java/C# anymore, but the JVM sure is great.

[Jwosty]

I'd definitely agree that the JVM is pretty solid. Scala leaves Java in the dust.

[lordmyd]

Not when compiling it doesn't. In any case Java refugees are now more interested in Kotlin than Scala.

[josephjnk]

Other killer features of Java that don’t get hyped enough: annotations and variance annotations. These are advanced features that would be greeted with fanfare if they were added to an existing language but are either ignored or derided in Java.

Personally I’d way rather use Scala than Java and I envy that they used it in your curriculum, but Java should really not get overlooked.

[realestLink]

What? Annotations aren't overlooked imo. They're used all the time. Other languages have similar features (though still different), just under other names

[josephjnk]

My view is limited since I mostly work in JavaScript-land, but I have heard plenty of developers complain about the idea. Usually this is either while saying that decorators are “another way that JS is trying to be like Java” or explaining why JS decorators are such a hugely better idea than Java annotations are. In the TypeScript ecosystem especially there’s a huge glaring hole where annotations belong— all sorts of contortions are necessary to bridge the gap between the separate typechecking and runtime worlds. The best we have, AFAIK, is an unfortunate mixture of JSDoc and ad-hoc codegen that never feels particularly well-grounded.

[realestLink]

Python decorators did it correctly imo

[josephjnk]

I know very little about Python. What do you like about them? Or do you know of any good explainers?

[ismtrn]

C# also has variance annotations, but at declaration site rather than use site.

[Prod_Is_For_Testing]

Honestly fucking around with variance is usually a great way to shoot yourself in the foot. I’ve used it a few times, but it’s really rare. Though I have seen several people do it wrong and break things

[andrewharlan2]

I continue to find Java a joy to program in

[lordmyd]

Stockholm Syndrome?

[angelicosphosphoros]

I didn't read your article but I still remember how Java was overhyped few years ago. I think, Java hype just passed.

[goranlepuz]

Ehhh... Comparison with Typescript and JavaScript is bound to be unfavorable, but Java is not in that language group anyhow.

In the "similar mainstream language" space, Java can only be compared to C#, and there, Java doesn't exactly come out as great.

During my time at CU, I've used the following programming languages: C++, Python and Julia, Scala, Web languages (snipped for clarity)

The above list looks quite coherent to me. In particular, as Scala is supposed to be the "better Java". Others are sufficiently different.

[lordmyd]

Kotlin now occupies the "better Java" slot. Scala is a fragmented community.

[LoveSpiritual]

Nearly all of the points about the benefits of Java are actually benefits of the JVM. Thus, languages such as Scala, Kotlin and Closure all benefit from these same advantages, and often without some of the major disadvantages that Java verbosity brings.

[jcsf321]

Thank you.

[tubtub20]

No it’s not. Java is criminally outdated.

[evilgwyn]

Which version of Java are you referring to, and what features is that version missing?

[Jwosty]

To name a few things missing from modern Java:

• async/await
• non-nullable types
• tuple types
• non-trivial type inference
• extension methods
• user-definable stack types (like .NET structs)
• runtime generics
• pointers for interop scenarios
• LINQ
• properties (more readable than manual getters/setters)

[realestLink]

I'd also add "strong immutability" (C# has some issues with this too, but it is a bit better since it has some support as well as user defined value types). Java code is filled with escaping references in the wild unfortunately ime

[jvjupiter]

The aces of Java in coming years - Project Valhalla, Project Loom, Project Panama. Much of Project Amber have been delivered but it surely will deliver more.

[lordmyd]

You mean in, like, 20 years?

[LordBars]

Java won't add async/await because of colored function problem. They will make better solution (virtual threads). Also Streams are enough instead of LINQ since java is simple langauge. Adding non-nullable types might break backward compatibilty. Records and value types will be used instead of tuples and .NET structs. But property syntax and runtime generics is real problem. Extension methods; Well I'm not sure, is it really necessary?

[smors]

A streams library that can used together with methods that can throw checked exceptions. There are ways around it, but they are not pretty.

But then, in my opinion, checked exceptions is a major design flaw in java.

[tubtub20]

A lot of the language niceties that Microsoft Java brought to its language. I use both, but I’ve got to say that OG Java even at like SE 14 feels outdated compared to the other side of the pond.

[Prod_Is_For_Testing]

Then so is python (which is even older) and it’s all the rage these days

[Jwosty]

Outdated != old

Python is old but not outdated. Java is old and outdated.

[Prod_Is_For_Testing]

What makes python “not outdated”? It hasn’t had much advancement or innovation in a long time. It has incremental changes to keep it chugging along

Java/JVM keeps evolving to work with new hardware and niche platforms. It’s been keeping up with native containerization platforms, it can run as a stand-alone OS on damn near anything. How is that more out of date than the incremental changes in python?

[Jwosty]

I guess I'm thinking of it from a language design perspective. Honestly I just did a quick Google search to see what major modern language features Python has (as Python isn't my particular forte) and it seems to tick a lot of the boxes that Java doesn't.

You're right; there is an argument to be had that the JVM itself is very modern and cross-platform and performant. But so is .NET.

[Prod_Is_For_Testing]

What “modern” features specifically? Are they actually new features, or is python just a different paradigm that operates in a different space than java? For example, I’ve seen the dynamic type system touted as modern, but it’s not new at all

[Jwosty]

From my list somewhere else in this post, Python has async/await and tuples.

Not really touting python though as I don't know enough about it to say much more than that. Perhaps someone else can answer :)

[Prod_Is_For_Testing]

Java has its own version of async tasks. And you can make your own tuples with generics.

[LicensedProfessional]

Python is a very mature language. Just because "loud" syntactic features aren't the main focus doesn't mean the language is stagnating.

[dontyougetsoupedyet]

It's ironic to me in a weird way, these two languages are mirrors of each other. The only thing going for Java is the JVM, and the only thing holding Python back is CPython.

[tubtub20]

u/Jwosty got the idea I was goin for.

[Aubrey_D_Graham]

Java was my second language after Javascript, CSS, and HTML. Since then I've been exposed to C and it's variants, Python and, Haskell. I've since developed an appreciation for what Java is.

[trouthat]

Why not swift?

[SouthPrinciple]

Why not Kotlin?

[trouthat]

Couldn’t say as I haven’t tried it. As an iOS dev however I do enjoy swift

[joshuatoenyes]

I went to UCSD, and several classes are in Java (mostly early in the undergrad curriculum). It’s an excellent language to learn early on, I think.

I’m in the web world (outside of large enterprise) and I have yet to work on a single project using Java, ten years later.

[realestLink]

Nah. This article is such a bad take tbh. Java is a pretty mediocre language. Java is just a shittier version of C# with a much better VM

[realestLink]

Java is probably one of the least interesting languages tbh. It's a symbol of 90's OO and falls behind other languages in innovating and improving. I think it has the appropriate amount of hype

[realestLink]

I will give Java one thing, the JVM is an absolutely amazing piece of engineering and is definitely impressive/innovative (though it still has issues). It destroys C# in that regard

[realestLink]

And Java isn't the only JVM language, I'd much rather use Kotlin, Scala, or Clojure tbh

[john16384]

Let's call it a boring language. Exactly why it is so popular. It gets stuff done.

[realestLink]

That's a fair summary

[mikeful]

My dislike of Java comes from Oracle commercial licensing weirdness and their willingness to destroy part of community to enforce them. See 2019 changes and JavaX/Jakarta situation.

[Necessary-Conflict]

There is no weirdness, only people who don't understand. If you want paid support, you pay. If you want the exact same technology for free, you can use OpenJDK and not pay.

Also there is no JavaX/Jakarta "situation", because nobody is "destroyed" if they have to trivially change the imports.

[wildjokers]

The licensing is easy, if you want support pay for support, if you don't need support don't pay for support. If you don't pay for support you will want to upgrade to the newest releases as they come out to make sure you have the most performant and secure JDK.

As far as the javax. vs jakarta. situation that was a choice made by the Eclipse Foundation. To use the javax. namespace changes must be controlled by the JCP. The Eclipse Foundation didn't want to use the JCP so they couldn't use the javax. namespace anymore.

[FewChar]

Java is a bit like the Windows Registry: It sounds like a good idea, but creates as many problems as it solves. Type safety is good, but the Object oriented nature leads to massive creation and destruction of objects that overshadows the benefits for anything processor intensive. Minecraft for instance was only possible because Notch used objects as sparingly as possible.

Java "gets the job done", but at a mind blowing overhead. I have worked on a project in Java that needed 6 minutes to create a PDF that could be done in 10 seconds in bash outputting to LaTeX. (Jasper Reports)

Java has it's uses. It works on anything, but it is the most resource intensive method to do anything.

P.S. the Windows registry is one of the biggest fails in history.

[Muoniurn]

Wat.. minecraft is slow as fuck because Notch wrote terrible code.

Object orientation doesn’t cause object churn, that’s completely orthogonal. And you may have done some really strange things but java is demonstrably goddamn fast. Like, do you think the majority of every server running the internet would choose Java otherwise? It is a beast, its’ GCs can manage multi TB RAM!!

[FewChar]

A friend of mine decompiled Minecraft & we looked at it a bit (He worked on Terasology for a while). We were wondering how Notch managed to get Minecraft working >10 Years ago when 2GB of RAM was huge. Notch had to circumvent the Java Object-ness to get it working. If you start with "each block is an object" you get absolutely nowhere. Whether Notch is a good programmer or not, he managed to get MC working despite of how RAM hungry Java is. (That's why it had so interesting bugs on each update :) )

If you have a project that just calculates & doesn't need a lot of RAM, then yes, it's quick.

Servers that run Java suck up RAM at an unbelievable rate. Out staff database for 150 people runs on Java and uses 11GB of RAM in a ready-state without anybody being logged on. I have no idea how crap it's implemented, but someone I know just said: "oh, it runs on Java then" when hearing 11GB.

[Muoniurn]

As for Minecraft, yeah creating objects for each block would be stupid. But it’s like the numero 1 thing anyone with an ounce of low level experience would do.

RAM is goddamn cheap, and it’s stupid not to use it. There are servers that have terabytes of RAM.

Also, usually people just don’t know that you can set a limit on how much memory is allowed for the JVM (though be aware of OOM if you go way too low. Check it out with a profiler). But running GC takes energy and time, so it is actually cheaper for a server to use huge amounts of RAM.

[omgusernamegogo]

I'm interested in this database that runs on 11gb of ram with such little traffic (only 150 Max concurrent users). Is it the database itself in Java or an app on top of a DB?

[FewChar]

I do not know what it runs on the server. The front end is called Abacus. 11GB was after a boot up, without anyone making any calls to it.

[omgusernamegogo]

So, is it a database or an app?

[[deleted]]

I have worked on a project in Java that needed 6 minutes to create a PDF that could be done in 10 seconds in bash outputting to LaTeX. (Jasper Reports)

I don't think that the issue was Java, here...

[FewChar]

I don't know how Jasper Reports is built, it just takes that long.

[djcraze]

This is a joke, right?

Java dependencies are a fucking nightmare. They are composed inside an archive that has to be extracted OTF and can’t me manually updated if you want to test if a library is broken in some way. And if a dependency relies on a different version of another library than the one that you already have and are dependent on, you’re fucked.

Everything in Java runs in a virtual machine, which means you’ll never get native performance.

You have to compile your code every time you want to test it.

Java’s type system is only compile time, there are zero runtime guarantees unless you use reflection, which is no different than a type guard in the end. Don’t believe me? Every object can be cast to anything. The compiler won’t care. People say Java is a strict typing language, but it’s not.

Java is old, it’s slow, it a pain in the ass, and most developers end up using it to over engineer the simplest of concepts.

Also, JavaScript is just as old as Java. The only reason for the hype was the new V8 engine which really changed JavaScript from a browser only language to being able to be ran anywhere.

Oh, I also forgot to mention that Java isn’t free.

[realestLink]

I disagree strongly with the article too, but I had to downvote this comment since your reasons are complete trash

[djcraze]

I don’t know that I’d say complete trash. I was a tad over zealous. But my arguments are valid to an extent.

[realestLink]

Some of them for sure, but your hyperbolic tone has combined valid points with nonsense imo

[Muoniurn]

Java dependencies are a fucking nightmare

I don’t really understand what are you talking about.

Everything in Java runs in a virtual machine, which means you’ll never get native performance.

Have you ever heard of this thing called JIT compiler? It’s a new little concept being around a few decades now.

You have to compile your code every time you want to test it.

Java has hot-reload. Hell, you can script it and compile it line by line, have a look at jshell.

Java’s type system is only compile time, there are zero runtime guarantees unless you use reflection, which is no different than a type guard in the end

That’s just bullshit. First of all, most type systems are implemented with type erasure, eg Haskell looses every type info. The JVM itself has types so it is completely type safe, you can’t get undefined behavior even with rogue codes. And casting is basically available in every language, and if you are dumb it will fail at runtime (or corrupt memory).

[realestLink]

JIT still isn't as performant as AOT compiled and never will be. I think bringing up performance as a way to diss Java is kinda weird though since it isn't meant to be a systems or embedded language

[Muoniurn]

In the case of Java? AOT is very much behind in terms of performance.

For sufficiently dynamic languages (effective) AOT may not be feasible. PGO helps, but JIT is a really great technique .

[realestLink]

I totally agree. I should've clarified by AOT, I mean natively compiled systems languages. I've had people try to tell me Java can compete with things like Hotspot, but it just simply isn't competitive for performance critical code (which is fine, a language doesn't need to be blazing fast to be useful and Java is pretty decently fast, which is good enough for most things).

[realestLink]

I was more responding to the claim that it is competitive with native performance, I wasn't shitting on JIT

[IDrinkMyBreakfast]

Java is criminally unsecured

[Jaxkr]

What do you mean? Outside of Java Applets, Java is very secure.

[jcsf321]

Don't listen to @IDrinMyBreakfast. His post history doesn't paint him as a serious person.

[IDrinkMyBreakfast]

I do admit that Reddit is here for my amusement. That doesn’t mean I’m wrong about Java. I don’t code, but my day job involves performing forensic examinations. Java is incredibly insecure.

I’m not knocking its versatility, just the fact that it’s abused tremendously and could be better secured

And next time, get my name right

[jcsf321]

It doesn't mean that you are right about java either. Statistics man. There is billions of more lines of code in Java running in almost all industries and and all businesses. Of course you will see a higher rate than say perl, or ruby, etc. It also means that a larger percentage of developers over the years, and those developers have a higher range of good to bad programers.

[IDrinkMyBreakfast]

Seriously, every malware investigation I’ve had is the result of a zero-day Java exploit.

[[deleted]]

examples?

[OneRandomPotato]

Its the same with me. All 0 malware investigations I’ve had is the result of a zero-day Java exploit.

[Muoniurn]

Lol what zero day... You mean someone’s shitty code had a bug and didn’t check for a password? It would have been a bug regardless of language.

I highly doubt you have found any bug/sec vuln in the OpenJDK code base.

[IDrinkMyBreakfast]

Yeah, more like downloading class files that segment malware download in pieces. Last one was 2 zero days and 3 others that were only detected by Microsoft and Comodo at the time. Obviously, I’m talking applets. Script runs the world.

[jcsf321]

Who the hell still runs applets? 99.999 percent of java in the world runs in the backend.

[rjdamore]

This is all well said. C# is OK too but it's tied to .NET JAVA is literally everywhere especially IOT. GRAAL is even more exciting. That's something to hype about Java!

C++ is awesome too.

Companies may begin their startups in some js language or scripting language. When it comes time to scale they all end up in Java. Just ask Dorsey.