Hacker News new | past | comments | ask | show | jobs | submit login
Greatest Java apps (oracle.com)
194 points by miked85 14 days ago | hide | past | favorite | 188 comments

To this list we could also add Cassandra, ANTLR, Spring Framework, JUnit, Jetty, Tomcat, Android etc. The list continues. The beauty of Java is not Java/Programming language - but JVM. It inspired people to make other languages such as Scala or Kotlin.

Yeah, but is the JVM worth it? It seems like VMs are now out of style, after decades of trying to make them performant at the cost of staggering complexity. VMs are still not more performant than native code and with the advent of SaaS, portability isn't a big issue anymore.

I don't think anyone doubts that the JVM is an astounding and amazing piece of tech. But what is in doubt is whether we need such a thing in the first place.

Most new languages (Rust, Nim, Zig, etc) advertise their native code generation prominently. People are tired of the shitty start-up times, inscrutable performance profile, and ginormous memory usage.

Even Oracle realizes this, with the recent push towards GraalVM.

And I say this as someone who would probably choose the JVM, Scala specifically, for any new SaaS project.

I personally haven't really used any desktop JVM app that I was happy with. If Intellij was native, I'm sure it would be 10x better, at least performance-wise.

This industry isn't a monolith, you have Javascript still chugging along, things like Lua as well. Microsft has the CLR as well.

Of course some stuff is conflating the language and the VM (which gets you to things like asm.js) but I think people acknowledge the value of what the JVM provides even in projects you cite (Zig has a whole thing about cross-compilation, for example).

And honestly? targetting a VM is _way easier_ than targetting native code generation. Perf-wise it might suck to try and then engineer good performance out of it (though you can get shared improvements with things like the JVM), but "staggering complexity" feels like a misqualification for something that got us a lot further down the "write once run everywhere" path than C ended up doing.

I would say that writing a rudimentary VM is about as hard as generating LLVM IR. The difference is that the VM will have terrible performance and the LLVM IR will have pretty good performance.

But will it provide introspection, garbage collection, and low-level niceties the JVM provides?

Will I be able to interface with all the huge amount of available java libraries? I could interface with C/C++ but there's already a ffi story (as ugly as it is) with the jvm.

I think part of the appeal of rust and go and new languages is the ability to leave a mark, rewrite or port or rethink an existing library in the new language...

It's a kind of progress but it feels like a lot of waste sometimes. And I say that as an avid Ada developer.

I have also reached a point of wondering whether I care about portability. I like the JVM ecosystem but I generally do not give a damn that the JVM abstracts the underlying OS to me since I have to go install it on the target somehow anyway.

If, tomorrow, I could generate native binaries and still leverage the excellent libraries that I can today, I wouldn't be missing anything at all.

I guess that's the point of Graal VM, right?

Theoretically. It's been reported to have lower total performance than the JVM, and a lot of libraries don't work with it yet. In any case, if GraalVM accomplishes its mission without the amount of handholding it requires today, sure.

I don’t know if I’d celebrate Spring... and Oracle would rather Android use “real” Java, not Dalvik.

The JVM was nice at the time, but I feel that languages like Scalia and Kotlin exist because Java was too conservative - and many of Kotlin’s great features had to be implemented using hacks and tricks to work-around the JVM’s now-primitive type-system. Also note that Kotlin can now target other platforms besides the JVM.

I think we can all agree the JVM is lagging behind the CLR, and the CLR is behind where we should be (when looking at the things that Clang is capable of)

That other popular Java-platform languages exist indeed shows that the Java language is too conservative for some, but that 90% use the Java language shows that its design is in line with what most people want.

And the CLR is about, oh, ten-fifteen years behind OpenJDK in compilation, GC and low-overhead deep profiling and observability. OpenJDK's C2 compiler is pretty much on par with clang in terms of optimisation [1] -- ahead on some, behind on others -- and in terms of sheer innovation and potential, its Graal compiler is probably the biggest breakthrough in compilation of the decade.

[1]: https://youtu.be/0yrBuPiGk8I

I would just say that usage isn't equivalent to want. I certainly can't put a number on it, but there is definitely quite a few of us that use Java because we are required to, not because it is what we want or the best tool for the job.

I know the CLR’s runtime performance has room for improvement- but I’m referring to the CLR’s capabilities and “language-enabling”-feature-set.

Its "language-enabling" feature set sucks. Reified generics for reference types force C#'s variance model on any CLR language that wants good code and data interop, and there is no portable good lightweight concurrency primitive. Sure Java is missing some important stuff like value types and tail call elimination (I don't think the CLR has the latter, either), both being addressed, but the CLR suffers from some early decisions that are nearly impossible to fix even if MS did show it had the inclination to fix them. Overall, Java is a more compelling compilation target than .NET, and Truffle is making it so much more so.

If you say reified generics I'm going to scream. Other than that one what else does the CLR bring to the table?

>I don’t know if I’d celebrate Spring

I've used SpringBoot recently on several projects after being in the Rails and Django and PHP world for a long time and I must say its super great.

I never could have imagined that I would praise a web framework based on Java 5 years ago.

Its lightweight, super fast (compared to Rails or Django), mature (its been around more that 15 years) and very stable.

It also supports Kotlin development

The more I learn about the Spring eco system the more I am suprised by how much stuff it covers everything from Spring Security to Spring Batch to Spring Reactive to Spring Cloud Task. Its mind blowing how much ground it covers.

Also, I hear the latest version will support Graal VM making start up times equivalent to native.

I strongly suggest spending time with it for those interested.

I've been beating this drum for a while. Spring has lots of legacy as it is 17 years old and has been through a series of technology waves over the years. That has both benefits and drawbacks.

With Spring Boot and Kotlin support it is now a modern framework that has straightforward solutions for most current problems. Built on a solid battle tested foundation (JVM + Core Spring)

Spring Boot (+ Kotlin) has been my goto stack for most problems for years now. There is a learning curve like most non-trivial software but once it clicks it's hard to go back to something else.

Java has become more nimble in recent years and they have been busy copying many features from Kotlin and C#.

And Clojure

And groovy, and surely more that I’m not remembering

In praise of Lucene, it's stated that

> Wikipedia replaced the Lucene engine with Elasticsearch, a distributed, REST-enabled search engine also written in Java

Elasticsearch is still using Lucene as core search engine though, so all that was replaced is the custom job control and wrapping around Lucene (SOLR?) by the one that Elasticsearch provides I guess.

Both Solr and ElasticSearch use Lucene as their search engine. Solr and ElasticSearch are basically server components wrapped around the Lucene library. With a fair bit of special sauce and extra features. Including, well, elasticity.

I gave up on lucene and solr on my dovecot server because of memory usage and use https://github.com/grosjo/fts-xapian instead

You may also be interested in https://github.com/tantivy-search/tantivy

I was the one who first requested that Doug join the ASF with Lucene. The rest is history... ;-)

Can you tell us more? Sounds like you have an interesting story to tell.

I'd nominate Bitwig for this. The UI is written in Java and is one of the nicest DAW interfaces around. The stuff they've been doing in the modular grid lately is particularly impressive. The fact that it's in Java means it works great on Linux too.



I nominate Spline, best in class skeletal 2D animator.


That's nice. Here's another one https://handwiki.org/wiki/Software:Atlantis_event_display

The Atlantis event display is a visualization program [1] [2] for the Atlas experiment, the largest, general-purpose particle detector experiment at the Large Hadron Collider (LHC), a particle accelerator at CERN

Does it use JavaFx for its UI? If not do you know what library/framework they use?

Based on this it sounds like the GUI is custom and that they don’t really use an existing framework.


I could be wrong, but at first glance, it looks like Eclipse's SWT.

Looks like JavaFX or Swing to me-- SWT doesn't really do themed widgets (everything looks like the platform's native controls).

wow, didn't know that, looks like awesome use of JavaFX!

Definitely, thanks for sharing.

Lucene? Android :) Tomcat? Maven?

The Minecraft coding community is amazing. What they get done without documentation is stunning.

It's funny how Java is not considered a good language for games... yet Java managed to snag one of the most important games of the decade in the end

It's really not great. Doable, but not great. That's why they moved to a classic C++ codebase instead on other platforms.

On a side note, I worked on Jpcsp, a PSP emulator in Java. Great for research and doing refactoring in the code quickly, not great for performance, even with a JIT. We wrote later PPSSPP in C++, performance was there quite easily.

Great work on PPSSPP. I haven't used it in a few years, but even back then the performance was great!

> It's really not great.

Could you provide some more information on what it was not great?

For games, probably the worst thing about Java, especially if you're still on Java 8, is the garbage collector. Its pause times can be brutal. This won't be noticeable for games that aren't too hard on memory, or games where framerate doesn't really matter, but it was definitely noticeable (and annoying) in earlier versions of Minecraft.

On Java 11 or later, I wouldn't expect it to be nearly such a big deal. At least not relative to some other issues. For example, it being a reflective language means that there's a fair amount of memory overhead that's really only there to support features that aren't so useful in games development. Also, there's a fair bit of overhead, in terms of both CPU and memory churn, to making calls into native libraries from Java. Nowadays, neither of those is a big deal for a large swathe of games, either, so I don't think one can really make a blanket statement that Java is not great for games development.

The "Java is bad for games" mindset is in part just historical bias. Performance and GC are thrown around as shallow excuses for comparing idiomatic Java with game design C++. Actually applying methods to reduce memory pressure like using arenas, and accepting vectors to mutate instead of creating new ones solve most of the GC penalty you paid for not having to think about it while prototyping. Large servers in java minecraft patch the server to do just that, and they operate well. I think the biggest barrier for Java in Games is the stigma and lack of resources relative to C++.

Yeah, of course Java can make games. Hell, even some high frequency trading shops are using Java. But the amount of effort you have to put in to twist a language and ecosystem that is practically designed around frequent allocation is just not worth it. Like, if you're writing zero allocation Scala or Java you're going to be writing C/C++ in the first place.

Might as well just use C/C++ instead of fighting the ecosystem tooth and nail.

> But the amount of effort you have to put in to twist a language and ecosystem that is practically designed around frequent allocation is just not worth it.

Do you an example in mind? Unity3D uses C# which is a garbage collected language.

And as anyone who as played Unity games would attest to, the performance is terrible. There's a reason why UE is much more popular than Unity for triple-A games.

Take Escape From Tarkov, an FPS that tries to be a AAA game and uses Unity. The performance problems that game has is frankly staggering.

But the shear volume of successful games built by Unity suggests that the extra work comes with a GC'ed language is worth it.

I mean, I don't think anyone is saying languages with GC are bad for a wide genre of games. They just are inappropriate for the most cutting edge, performance intensive games.

Unity is a lot easier to get started with than UE4, so I understand the popularity. But for some games, the player can really tell how inappropriate the engine is. You can feel the GC churning away: poor performance, high dispersion of fps, frequent stuttering, etc.

While any game using any engine could have these problems, it's especially prominent in unity games.

That's so true, you really can 'feel' Unity...it's mushy movement.

AWS too. A large portion of it is written in Java

Any references?

I guess that they wanted to go down the route of "hardly controversial and highly popular" applications, that's why they didn't include Maven.

Granted, Maven is an essential piece in the Java ecosystem, yet it seems that many developers are highly opinionated about it.

Citing Maven also feels a bit circular. It's an important Java application, but being a build tool it's only because there's lots of Java out there to build.

Minecraft and a lot of the other apps are terminally impressive, so it's easier to justify the ecosystem that produced them.


It's mentioned in the Wikipedia search section.

Android stole and abused Java :(

So what's funny to me is how Oracle here is bending over backwards not to give Google credit for pretty much anything. It's actually hilarious.

I laughed at Eclipse Collections. What? No mention of Guava, even though it's used way more. It's practically part of Oracle's copyrighted Java API.

but of course the most hilarious omission is, of course, Android. And you can say "blah blah Dalvik VM blah blah" but... it's Java.

And I have to say a word about IntelliJ (and Jetbrains IDEs more generally). They're the standard by which I judge every other IDE. To put it another way, they're the reason every other IDE makes me sad. Even VS Code.

I have used Java on and off since 1998, am yet to ever touch Guava.

Android Java is Google's J++, with its half baked Java 8 compatibility, and deserves the same treatment that J++ once had.

Android Java != Java so no credit needed to be given. Though Google does make Java contributions in other libraries and projects which is very welcome by the community!

Their wrongdoings with Android to the Java eco-system are more harmful than whatever contributions they might have done.

Guava was really popular 10 years ago, after that other libraries have caught up, not to mention Java itself.

And IntelliJ was once indeed the standard but is slowly becoming the new Eclipse because it's so bloated. I recently tried VS Code and I was amazed how fast and lean it was, I am definitely switching.

Android isn't Java. Java is a specification of a platform (a set of them, really) and Android doesn't come near to conforming to it.

Sort of mystifying that ByteBuddy (a library) is included while Spring framework is not. I realize that some people point to the edges of the Spring ecosystem as proof that it is low-quality, but it's hard to argue against the framework itself being great.

Edit: To clarify, I also don't agree with 'proof' of Spring being 'low quality'. In my experience most who criticize Spring don't understand that it is a loosely coupled collection of things implemented on top of IoC/AOP, and are frustrated when they are forced to diagnose things that go wrong. From the beginning, Spring moved fast because it wasn't bogged down in committee, and it covers huge portions of software development. Quality does vary between the value add sub-projects, but it's amazing what the Spring community has done with IoC/AOP.

Yes, Spring is good, and in general there's been a lot of innovation started in Java and spread elsewhere. The whole "Dependency Injection" idea started in Java, and a lot more stuff started there too, or at least was popularized AFAIK. For example, pattern languages themselves. But some great libraries like JodaTime came from there, as did Doug Lea's very nice rendering of better concurrency primitives - and both of these ultimately got into the core library itself.

Wasn't the "Gang of Four" book written entirely in C++?

Yes; that's why I added the caveat "or popularized".

What are the odds that a language known for its use in boring enterprise software is the language used to create the most popular video game in history (Minecraft). If C++ was a person it would be mad/salty at this fact.

It's a great reminder that the customer doesn't care about the code. What matters is the experience and overall fidelity of the product shipped.

The language you pick, the quality of code you write, the comments and documentation, are all products (gifts) targeting your future self, future peers, and employer when it comes time to make changes to the software.

> the customer doesn't care about the code

I'm not sure this applies as strongly in Minecraft's case specifically, because of the critical importance of its modding community to its wild success. Normally it wouldn't matter what language you pick in terms of how popular the game is going to become, except it just so happened that by choosing the JVM they gave the ability to the community to decompile the game and add the content they want. Maybe this wasn't intended and Notch chose Java because it was what he happened to know, but it's my belief that if Minecraft had been written in C++ instead then Mojang would not have the brand recognition it does today. Anecdotally one of my friends tried the RTX version of the game which was rewritten in C++, and his reaction amounted to "it's fine, but there's no mods, so it's irrelevant." And that's in spite of the fact that modded Minecraft is a minefield of incompatibilities between years old versions and can easily consume 10 gigabytes of RAM and millions of extraneous CPU cycles. Nobody cares, because at the end of the day modded Minecraft is the only way they can get the specific experience they want out of a video game, and the only reason this is possible at all, even if it will never be performant, is the JVM.

But that's only because Minecraft is one of the most popular video games in history, and not the kind of thing that a developers for a game nowhere near as successful would worry about before gaining a sizeable audience. What good is a modding system if not many people want to use it? And depending on the game a mod system might not be as warranted, so in those cases the choice of language doesn't matter as much.

> it just so happened that by choosing the JVM they gave the ability to the community to decompile the game and add the content they want

That wasn't their intention; Minecraft code was originally obfuscated specifically in order to combat reverse engineering and modification.



True, but I find it amusing that none of that even mattered and the community was persistent enough to build an entire architecture, database and IRC bot solely for deobfuscating the source of Minecraft anyways. So long as nobody would get sued for it, it was still possible from a technical standpoint, so the motivated people did it anyways.

And now it seems that Twitch and other "official" entities have conceded to the fact that modding was really the only reason so many people play Minecraft at all and they integrated installing mods into their official launcher. Server hosting for Minecraft is a legitimate business since you'd need enough RAM and single-core performance for mods also, so they advertise "mod-capable" hosting plans.

On top of that the entire decompiled and deobfuscated source of Minecraft 1.22 is sitting on GitHub to search through.

The sheer extent of modding capability that Java enabled caused this weird conflict between the interests of the parties wanting to retain the intellectual property of the game through obfuscation while at the same time admitting that people undoing it and using the source themselves for modding is never going to go away, and trying to forcefully get rid of it for the sake of this legitimacy anyways brings no benefit and would only anger and drive away the audience who already comes to expect mods. And then some group would probably just hack together some unsanctioned server/client package from the JARs that are already widespread and keep playing the old versions forever, since they'd still want to play modded Minecraft anyways, and there's no reason the whims of a few corporations ought to invalidate the past several years of modded Minecraft experience they've lived through already. At least it's a better case for modding than purely competitive games since a lot of Minecraft is about construction.

Sometimes I think that the only games that will truly last for the ages where new things are still being created and discovered regularly are the ones whose source code is in the control of the players, and they aren't actively poached for "stealing" in an attempt to extract a few more dollars per person. That, and the playerbase being motivated enough to keep developing content for them. It seems Minecraft is one of those few games as of present.

> That, and the playerbase being motivated enough to keep developing content for them.

This by far is the most important thing. You could have a beautiful open source game but if no one knows about it or wants to play it, it's less than useful.

Some of the biggest modding communities I am aware of came from closed-source games; the Sims has always had strong, years-long modding lifetimes, and SimCity 4 and Cities Skylines after it had total overhaul mods that changed entire game systems, as well as thriving communities of less ambitious mods.

C++ minecraft should have an SDK for mods

The proven example that instead of spending endless hours discussing what languages are good for creating games, one should focus in creating them in first place.

Incidentally C++ also had to fight against Assembly, C and Pascal for adoption among game developers, and the Playstation SDK was one of the contributors to change this.

> most popular video game in history

* citation needed

The most popular game by player count is CrossFire [1]. All I see is that Minecraft has the highest unit sales for a video game across all platforms, but Minecraft for consoles and mobile (which make up a majority of sales [2]) are written in C++.

I would argue that Java would have been a limiting factor for Minecraft reaching its current levels of success given the fact that the PC gaming market is relatively small compared to the console and mobile gaming markets, and it would've been nearly impossible to port the Java edition to so many different platforms.

[1] https://en.wikipedia.org/wiki/List_of_most-played_video_game...

[2] https://minecraft.gamepedia.com/Bedrock_Edition#Sales

And to this day people keep complaining about the modding capabilities of Bedrock.

I'm pretty sure the most popular video game in history was implemented in TTL.

(Though Java versions certainly exist, too.)

It's also worth noting that Minecraft was originally implemented in Java, but, in order to get it running on consoles and mobile, they had to port it to C++. Which doesn't discount how much Java contributed to its early success. (Most importantly, I'm guessing, by making it even feasible in the first place for a single person to implement it in so little time.) But still, the big picture version of the Minecraft story does more to support than challenge the main reason why C++ is considered the language of choice for games development. Because, yes, Java got it off the ground, but it was only a couple years later that they had to port it to C++ in order to access a mass market.

The Java version is still very popular due to its support for mods.

It absolutely is, and it's my preferred version. But I think I remember seeing somewhere that the vast majority of unit sales were of versions that were written in C++. My guess is that, if it had stayed Java only, it would have still been extremely popular, especially by indie game standards, but would not have become quite such a global phenomenon.

The C++ versions may drive new sales on additional consoles but measured by hours played I would expect that the Java version of Minecraft still dominates.

What's the game implemented in TTL?


I guess as a % of market share it was pretty popular :)

What graphical library did he use to implement Minecraft? Or did he roll his own?

He used lwjgl library

Well that assumes lot of boring enterprise software is not written in C++.

TensorFlow is written on top of C++, how boring is that, I think it's one of the coolest tech.

Yea probably, I doubt that Minecraft would've been any less succesful written in C++ or any other language though.

I've heard that the relative ease of decompiling Java might have contributed significantly, since it made mods much easier than they would've been with C/C++.

Yeah, the game is almost source-available, thus almost infinitely moddable. Games that provide neat modding APIs (thinking Factorio, Rimworld) are, while commendable, inherently limited. If Minecraft were C++ you'd have to be able to recompile it yourself for equivalent moddability.

Minecraft isn't source available, it's just that people in the community have put a ton of effort into decompiling and deobfuscating it. Granted, this probably wouldn't have been possible if it were written in C++.

(At least, this was how it was pre-Microsoft. I haven't followed it since then.)

Could Minecraft have succeeded if it had a sub-level scripting language, like Lisp? The way that AutoCad uses it for its sub programming. Or the way Emacs uses Lisp for macro programming.

Or did it need the full Java source code to re-mod the program?

AutoCad and Emacs aren't really comparable in their use of Lisp. Emacs is essentially an Elisp interpreter with some features for buffer management, while AutoCad just uses Lisp as a traditional scripting toolkit. Emacs is built with Elisp, AutoCad is not.

The C code in GNU Emacs does a bit more than implementing a 'Lisp interpreter'.


Quite a bit of the actual GNU Emacs application is using libraries written in C. See for example the font code.


This is different from some other Lisp systems, where only the base language runtime contains some C and/or assembler, and the actual application is mostly written in Lisp using an FFI (foreign function interface) for library calls. For example the GUI of Clozure CL is written in Lisp using an Objective C bridge, and not directly in Objective C and then called from Lisp.

Thus Emacs Lisp is also somewhere in a continuum of implementation and extension language - using C not only for the Emacs Lisp language runtime, but also for basic application implementation...

I'm confident the community driven modding contributed to Minecraft's success in a massive way.

Depends. Success measured how? For the end user -- the players, that is -- it would likely make little difference. For the developer, it's very different. A game that doesn't get made at all is infinitely less successful than one that exists.

> If C++ was a person it would be mad/salty at this fact.

Are you serious? Wake us up when somebody implements something as complex and performant as UE4 in Java. Or even UE3 for that matter.

The concurrently developed Minecraft Bedrock edition is written in c++. That is code base for Widnows 10 Edition, Pocket Edition, and current console versions of the game.

And yet people here on HN have told me in recent threads, when discussing Java, that:

- Java is not suitable for enterprise software (yes! Some people here actually believe that).

- Java is not a good general purpose language (but Minecraft was written in Java. Or even better, the list of very varied apps from this article shows it's indeed a good general purpose language).

What these people actually mean is "I don't like Java". Because Java hasn't been "hip" for years, this makes people claim all sorts of absurd things about it. Things that directly contradict known history.

I work in Java every day, and I agree it's been a huge success. But I also don't think it's a good general purpose language. It's absolutely full of warts and gotchas and ergonomic problems and questionable design decisions that even the people who made them have come to regret.

But known history tells us that there is very little correlation between a language's success and how well-designed it is. Outside of software, too - I think the archetype for this phenomenon is probably VHS and Betamax.

> It's absolutely full of warts and gotchas and ergonomic problems and questionable design decisions that even the people who made them have come to regret.

And which general purpose language isn't?

> questionable design decisions that even the people who made them have come to regret.

Such as?

I think the most interesting one to me was an interview with Joshua Bloch in the book Coders at Work. It was to do with generics, of course, but distinct from the usual surface-level debate over type erasure. He felt that generics were rushed, and that they could have done a better job of sorting out the details of how things were going to work at the language level if they had given themselves more time.

This is a good read[1], and they're "fixing" them with specialization.

[1] https://cr.openjdk.java.net/~briangoetz/valhalla/erasure.htm...

Wild mixes of consumer and provider API's for example in Swing. The later designs have been much better in that regard.

The built-in http client library is borderline horrible.

As someone who's not a big fan of Java, I don't get those arguments.

If anything my argument for Java would be that it tries to be good at -everything-, and because that attempt started from day one (versus, say, C# starting primarily on desktop, then Web, and worrying about smaller targets and big servers later).

And I think it's pretty good at all of that from a 'capability' standpoint.

But because it tries to be all things for all people, it's pretty easy to wind up down rabbit holes of large frameworks. And that leads to the warts Java has from a usability standpoint.

I would say its suitable, but I wouldn't say it's a good general purpose language for a variety of reasons. The first being that "good" is totally subjective. It feels like it has lagged behind its competitors both in terms of language features and API design. Its generally crappy for GUI apps. It doesn't really excel at anything in particular unless you're already invested in it. Even it's original premise of "write once run anywhere" is mostly irrelevant now, and there doesnt seem to be a future for client side Java apps outside of Android.

Overall I'd prefer to use just about anything else in pretty much any domain where Java would be a consideration. It may not be an inherent problem with the language itself, but its ecosystem in my experience leaves it as one of the worst general purpose languages in terms of productivity while not offering a sufficient advantage to make up for that.

All that being said, Java is still good enough most of the time.

My experience with the ecosystem is the opposite. The ecosystem is so good, and so mature, it's hard to argue for other technologies at my current job.

For any fancy new language/framework, you must show you understand its performance issues, pitfalls, metrics and monitoring tools, etc. Few languages beat Java at this for serious work.

The performance of the Java version of Minecraft is so terrible that the entire game had to be rewritten to be played on consoles.

Minecraft was not popular because of Java, Minecraft was popular despite Java.

I strongly disagree. A big part of minecraft's popularity is due to it's mods scene, and it's mod scene is so successful because modders could decompile minecraft's classes and build a deep understanding of how minecraft works under the hood.

The game had to be rewritten because Microsoft is a C++ shop and game consoles SDKs don't support Java, and it was definitely easier to port the game to C++ than to create Java AOT compilers for game consoles.

That's highly debatable, not a point of fact.

And the rest of the apps from the article? Are they also successful "despite Java"? At which point are you willing to admit that maybe Java was suitable for general purpose programming? Which amount of evidence would convince you?

What's debatable, that the Java version of Minecraft had terrible performance or that the console ports are not written in Java?

About your other question: I only mentioned Minecraft.

The point that's debatable is the point you led with, that Minecraft "had" to be re-written because of poor performance.

Not that it was.

Of course, all of the new advancements have come in the Microsoft-built C++ version that runs an order of magnitude better (including like ray tracing and VR)

Although C++ allows for better code optimizations, it isn't as if the team that took over later Java versions was doing anything great.

Using classes to represent points and vertices instead of arrays, and allocating in hot paths, really?

Today I learned that almost every IDE I have ever used is written in Java.

And now you understand why none of them work very well!

I laughed, but PHP Storm and IDEA are very good tools imo.

Netbeans was quite good when I used it as well, although clunkier.

They can be very memory hungry though (of course).

The list generates some mixed feelings - #16 for example, where the inventor/maintainer got driven away by Oracle's acquisition of Sun and forked Jenkins from Hudson.

It's obviously and understandably a bit biased. There are a few omissions:

No mention of anything mobile even though there are a few billion phones out there running Android with a huge app ecosystem of Java and Kotlin based stuff. Of course, that's a non Oracle flavor of Java as Sun sort of lost the plot on the J2ME front (another omission). J2ME was of course more successful than applets ever were until Android happened.

Listing Eclipse and Netbeans (1 bullet) before Intellij (arguably more popular than those two combined) is also a bit weird. In any case, Intellij has largely switched to Kotlin, which is of course a language Jetbrains, the creator of that IDE helped create to replace Java. So nice that they still get a mention. But really, that whole ecosystem is now powered by Kotlin more than Java.

Spring/Spring-boot is another painful one for Oracle because it largely sidelined J2EE related products and standardization. Tomcat and Jetty sort of survive as low level components you can optionally use to run that. The Spring ecosystem is shifting to Kotlin rapidly as well. As is Android, of course.

So, it's understandable why Oracle prefers to not talk about those because these are all examples of where Java was successful but Oracle/Sun wasn't.

I look forward to JetBrains replacing the JVM and its standard library, and GraalVM in the process, given that Kotlin is so good.

> Spring/Spring-boot is another painful one for Oracle because it largely sidelined J2EE related products and standardization.

I'm thankful for J2EE and things like EJB 2. It's complexity gave rise to Spring and it's amazing ecosystem of frameworks and tooling that we have today.

I gave up on Java when Oracle prematurely rolled JavaFX into the JDK and got rid of the dedicated bug tracker. I was using JavaFX a lot and frequently ran into bugs. I didn't mind the bugs because I thought the tech had a ton of potential, the JavaFX developers were really good, and it was easy to get things fixed.

However, as soon as they rolled JavaFX into the JDK I knew it would be a nightmare for me. Without author status in JBS you're relegated to being a second class citizen who has to submit bugs though the poor door (bugs.java.com) and JavaFX fixes couldn't be pushed out as quickly because of being tied to the JDK.

That was after years of broken promises about mobile which didn't help. They were also claiming to make massive investments in JavaFX, but if you HG churned the repo there were only a few developers doing all the work.

It's too bad because I really liked JavaFX. It was nice to develop with and I'm convinced that Oracle's mismanagement is the primary reason it wasn't more successful.

Do you now realize that it's been split out of the JDK again? https://github.com/openjdk/jfx

Yeah, I still check on it every once in a while and I updated a small app to JDK11, but the industry has changed a lot since then. I know Java is still huge, but IMO that's in spite of Oracle, not because of them. The proverbial ship has sailed for me. If Oracle told me the sky is blue, I'd be looking up to verify it.

I completely gave up on JavaFX the day Microsoft bought Xamarin. My impression at the time was that Oracle just didn't care about JavaFX and barely supported their own developers. AFAIK they never did anything to encourage 3rd party developers even though there was some really cool stuff. Ex: Microsoft ended up owning RoboVM.

I also remember being frustrated the first time I looked at the JavaFX repo myself and saw how few committers there were. All the while Oracle would be simultaneously claiming they're investing in the tech, but actually dumping stuff [2] on the community. It's like they viewed open source as nothing more than a way to externalize costs for things they didn't want to maintain.

I never had the inside track on anything, so I don't know what the real story is, but my impression of it has always been that it was badly managed by someone higher up the chain than the people that managed JavaFX directly. Based on my experience everyone on the JavaFX team always made a ton of effort and tried foster a small but growing community.

Speaking of community, it was plagued with the same kind of doublespeak. Oracle would be on the mailing list telling everyone they wanted to work with the community [3] at the exact same time they were telling all of us to file our bugs using a plain text input box on bugs.java.com. How the hell do you submit a runnable test case using a single, 4 line high text box?

And if you need any kind of indicator to demonstrate Oracle's lack of ability to foster a developer community or provide developers with modern resources, go look at that bug filing system I keep complaining about. It's still the same awful system that looks like a holdover from the 90s.

This is all just my opinion, but I honestly believe Oracle squandered a huge opportunity with JavaFX.

1) https://bugs.openjdk.java.net/browse/JDK-8091544

2) http://mail.openjdk.java.net/pipermail/openjfx-dev/2015-Janu...

3) http://mail.openjdk.java.net/pipermail/openjfx-dev/2015-Dece...

Not really “apps”, but Java features prominently in the backends of many major tech companies. Off the top of my head, I believe it’s the main server-side language at Amazon, and one of many prominent server-side languages at Google, Netflix, Apple and Uber.

What do you mean by "apps" then? Ofcourse any modern app will have mix of technologies, I think it's fair to call it "app" - perhaps an Enterprise Java App or Backend Java App to be exact.

When I think of an application, I think of something used reasonably directly by an end-user. From the linked article, things like IntelliJ IDEA, the Maestro Mars Rover controller, Minecraft, Hadoop, etc. Admittedly, this is just my personal definition, "app" is a pretty loose term.

For, say, the "Google Sheets web app", I'd say the entire piece of technology, frontend and all backend services, combine together to provide an application. But if the Google Sheets web frontend depends on, say, 20 different backend services, I wouldn't say that any one of those services is an app on its own. Each service makes up a part of the backend of one-to-many apps. And, from what I know of Google's tech stack, different services might be written in different languages - primarily Java, C++, Python or Go.

I like to add clojure it is written in Java, so I guess it counts.

But seriously what do you like about Java and why did you choose to work with it? What problem does it solve for you? I'm curious! (don't comment when you don't like it)

Established best practices of good software engineering, vast selection of libraries for pretty much anything, high performance code, cross platform availability, scalability. Pretty much anything you need to build a solid backend exists here and not to mention the large Java dev community.

H2 database is pretty awesome. Such a pleasure to use vs SQLite and even vs some large-scale RDBMSs.

Second that, I used H2 as the basis for a time reporting/invoicing system that has been runnin without issues for 7 years now.

As far as SQL databases go, definitely my best experience, it just works.

I always come back to H2 for an embedded db. So user-friendly! SQLite is nice but H2 useability and standard SQL support is awesome.

I suspect the greatest java apps are the ones that can't be written about. The ones that run in a data center, that are a tremenous advantage in the market to the companies that run them. These are so important to the app owners, that they don't want others to know about them.

I'd have to give Tomcat the #1 spot for killing off the worst parts of J2EE.

OMG. I've set up Confluence servers and Tomcat was the most nightmarish part of that experience. The idea that Tomcat was an actual improvement on something sends shudders up my spine.

TBH, its not Tomcat but the terrible application packaging by Atlasssian. There was a time when they had it right. A single WAR file. Just drop it in the tomcat webapps folder and (depending on your preferred config) boom! Application deployed. Your data and configs lived in the path defined by JVM_OPTION -Duser.home | -Duser.dir or environment variable CONFLUENCE_HOME (IIRC). Backups were a breeze. Just archive the data folder. Updates were a breeze too! just replace the WAR and restart. Case in point Jenkins deployment in tomcat. Ahh super painless. Running multi tomcats on single host for application separation was as simple as CATALINA_HOME and CATALINA_BASE being set. Now we have a spaghetti monster called kubernetes that makes people think their apps will run better in it. Works for some but not for all. very much like that gym membership.

You would have had to lived through a full blown J2EE app on Websphere/Weblogic/JBoss to appreciate it.

OMG yes. So many times all you needed was what Tomcat delivered, but had to go through the convoluted and slow config of WebSphere. WebLogic was better but that's damning with faint praise.

Im still in the jboss world. Though we've solved the problem, we just don't ever deploy more than 1 app to a jboss app server. I'm very much ringing the spring bell around my work. but the cutover of all our legacy stuff that is running fine will be decades.

Tomcat definitely shows its age, but I also see some amusing parallels to modern cloud / IaaS architectures in a heavyweight application that implements standard APIs for code you can HTTP POST to it.

I'd say Spring takes that crown.

I still give Tomcat credit for taking Websphere and Weblogic out of the way. That opened the door for Spring.

JBoss took WS/WL out of the way.

Disclosure: I was one of the main people who got Tomcat open sourced.

No mention of Runescape, Classic, 2, and OSRS? I suppose "applets" covers it but I think it needs its own mention.

That is exactly what comes to mind for me when I think of "Java games". Absolute classics

I'm not surprised that Vuze (or its clone/successor BiglyBT) is not there. But it's one of the oldest desktop torrent clients, and is still being developed.

I find it a little weird to mix applications and libraries in the same list. But if libraries are considered, I would definitely nominate Hibernate: the most powerful ORM out there accross all languages, and it's been a must grab for any of my projects for almost 2 decades.

I haven't been much of an ORM userm but what makes it so special? Anything comparable in Javascript or Python land?

They might not like being associated with it, but JDownloader is amazing Java software. It's fast, looks good, integrates with all desktop environments I've used and still works impeccably.

I wish Java had a solution for web+platform UIs. Webapps that then run in Electron is by far the most annoying thing I've had to deal with as a user.

I was surprised how much I enjoyed reading that, in a memory lane sort of way.

I haven’t used Java in a long while and I haven’t updated my book “Practical Artificial Intelligence Programming With Java” in many years. I decided to rewrite rather than stop distributing the book. I started the rewrite about three weeks ago. First step was tossing out about 1/3 of the material, stressing machine learning, adding probabilistic programming, and updating the semantic web material.

After taking a whole day getting my head back into coding in Java, I am actually enjoying it. I still like Common Lisp and Haskell a lot more.

After reading this, I think I need to learn Eclipse Collection and Micronaut.

There's a competition between Micronaut vs Quarkus also. Pls have a look

Helidon follows behind, but yes I agree that Micronaut and Quarkus are probably front-runners for this space.

I'm planning to get a Masters degree in CS, and it bothers me that the program I chose uses Java as the primary language. They have an awesome theoretical curriculum, but it looks like I'll have to use Java to complete all the practical tasks.

I'm a Node/React web developer, I want to build a SaaS startup, and I'm not really interested in writing Java apps, I doubt I'll ever want to use it for something.

Do you guys know if Java would be really painful to learn? It's hard to get motivated about learning a thing I'll probably never use in practice.

You will probably learn many languages in your career. Most of the understanding you'll gain will apply across languages, so I wouldn't worry about it being a waste of time.

Learning Java should force you to understand object oriented design, as it is hard to do anything well in Java without it (though some try). While there are signs that OO's domination is nearing an end, there are reams of code out there that require a good understanding of it.

It’s not likely that any university is going to teach masters classes in JavaScript, that’s for sure. So you’d have to use a different language than JS anyway. Advanced topics you would learn like ML, computer vision, distributed systems, big data stuff all already have their languages that you have to use anyway and not many (if any) are JS.

Also, if you are going to be a React web developer, the theoretical/advanced stuff they teach you in an MS program is likely not going to be relevant at all to your actual career.

Source: current MS CS student.

Java is a common university language, and an even more common industry language. I think gaining knowledge of the Java ecosystem and Java architectural patterns will only be beneficial to you in your professional career. Hopefully you'll find places you see advantages in Java, and places you see advantages with Node. This will help you make better decisions when building production apps.

I hate Java for lots of reason, but it does do a few things really well, one of which is that it is easy to learn. Most of the core libraries are very consistently designed, so you don't need to hunt around documentation to find something. Instead you type import java.util. and look at the autocomplete list for the collection you want. Most of the standard libraries implement the same interface, so using them is almost always the same.

I haven't used Java in years, but I'm very certain I could pick it up again immediately with nothing more than an IDE. Contrast that with python, which I use almost every day and I still need to visit stack overflow to perform rudimentary tasks because libraries for it are a mess.

grind some leetocde questions in Java. after a while it made me appreciate the explicit Type declarations and interfaces. Like, you begin to wonder, do you want to use a HashMap<> or TreeMap<> as your map implementation. Or a LinkedList or ArrayList as your implementation of List etc... I find languages that are more dynamic like js/python dont make the user think as much about this (which is great in some cases, but if your doing academic CS stuff... kind of helps in some sense)

Java will at least help you understand stuff like static typing in TypeScript and classes in ECMAScript 6. In any case, skills are readily transferable across programming languages.

Java is used everywhere, why do you think you’ll never use it?

I do contracting work and mostly focus on Node/React, yet I still encounter Java all of the time. Especially Java with the Spring framework. With how entrenched Java seems to be, it's probably something you will come across from time to time (especially in the web development world - at least from my experience). Also, I find that JavaScript devs have an easier time learning Java than Java devs have learning JavaScript.

There's a long career ahead of you, and if you ever work at a large company, or even if your startup grows so that its backend needs to really scale, chances are you will be using Java. Its combination of performance, productivity and observability is hard to beat. Many companies start off with some other platform and then adopt it as they grow.

I graduated undergrad two years ago, the majority of my CS classes were taught in Java. I now work in full stack web dev (Python, Django, React) and tinker with embedded electronics on the side.

Java was picked because (for the most part) it just works on everybody's machines, it comes by default with a large set of libraries, and it can build standalone executables (great for grading purposes). You don't have to explain why MacOS comes with Python, but you shouldn't use that version of Python. Java of course has its peculiarities, but so does every other language.

And as you say, you won't just be learning Java, you will be learning how to develop software. Over time and with exposure to multiple languages you will find switching between them is possible. You may (will) have preferences but with a solid foundation you can say "I recognize that this is a loop over an array, I don't remember the exact syntax in this language, but I know how to look it up".

I'm not sure what your situation is for a masters, but for the best odds of job searching post-undergrad the best advice I could give is have several projects which you can talk about the implementation specifics (why did you choose this pattern) and the big picture (why did you choose this architecture). For an entry level positions the exact language didn't matter when job searching as long as it was in the ball park.

TL;DR You're going to school to learn computer science and to illustrate those concepts they're going to use Java. That knowledge WILL be transferable to other languages. For maximum value explore and tinker with other languages on the side.

And as a bonus, a lot more of the world runs on Java than you think so it will be valuable to have on your resume.

>Some credit Minecraft’s early success to the fact that players could play in a web browser via Java applets rather than having to download and install the game.

I never knew this was possible

It was possible with the early, finite-world-creative-only "Minecraft Classic", but as long as I remember (I started playing mid-Alpha, a few months before the Nether was added) the game was played through the launcher.

I say this as a Java developer, but I hate UIs written in Java. Native UIs are always superior. IntelliJ comes to mind. I used it for many years, and it always felt "different". There were weird inconsistencies in rendering, focus and behavior that were annoying. Same with NetBeans.

On the other hand, I think server side Java is still great.

It's great to see our team's tool, Deep Space Trajectory Explorer, come in at #2! DSTE is a custom software tool that's being used by NASA Johnson Space Center to design/visualize complex orbits for upcoming missions to send astronauts to the Moon in 2024+!

Jenkins the greatest Java app ever written .... hmm

Wasn't Google docs written using GWT?

Originally no, but it was written with Closure Compiler which is a Java app.

These days Google Docs, Gmail, Spreadsheets, Hangouts, etc are hybrid apps that contain a core written in Java and was transpiled with GWT but now use J2CL.

I use Pentaho Data Integration every other week, it's quite nice for ETL.

For reference, this is what that page shows when opened with uBlock Origin + uMatrix: https://imgur.com/a/yd9OAPB

This might be confirmation bias, but I actually think it conveys pretty much what it should. :)

Also Azureus, featuring legendary laggy java gui.

No mention of Android? lol butt hurt

Ummm, its an Oracle site :)

I guess it´s because Android is not mainly consisting of Java code, unlike for example Minecraft. Correct me if I´m wrong, but isn´t Android made with mostly C and C++?

Kernel (Linux) and android runtime (previously dalvik vm) plus some native libraries are C(++). The rest of the stack running in the user space is Java though (with support for native code).

They are slowly moving to Dart, but the lions share is still Java. My guess is that they are trying to get away from the reach of Oracle lawyers.

Tell that to the Android team busy replicating Flutter in Kotlin.

Pardon my faux pax. The point was that the move is away from Java, whether Dart or Kotlin.

Waiting for them to rewrite Android Studio in Kotlin and the complete Android infrastructure that depends on OpenJDK for the emulator and AOSP builds.


> The IntelliJ Platform is a JVM application, written mostly in Java and Kotlin

Pretty sure Kotlin was birthed to address issues they ran into while developing IntelliJ

Android Studio is built on Intellij.

Still depends on JVM and Java, if Kotlin is so good they can certainly reboot their eco-system using Kotlin/Native.

So not impressed. Still waiting for, "write once, run anywhere" to actually work.

I worked on a Java desktop app, that had a highly complex UI written in Swing, for ~14 years. We only officially targeted Windows as a platform. For a few years I switched to a Linux development machine. The only code change required was for our third party license dongle - to reference the correct native library needed for machine fingerprinting. We also ran it on another developers Mac just to see if we could - again we only had to comment out the licensing code and it works flawlessly.

So from that experience I would say Java definitely lived up to Write Once Run Everywhere. FWIW we used the Nimbus Look and Feel. Other LAFs may not have had as much polish applied.

It did, once you finished debugging everywhere.

That aside; these days, it actually more or less works.

I avoid it as far as I can after having built a couple of systems in the language. For all its faults, Go is still a much more pleasant language to solve the same kinds of problems in.

But my latest project needed multi-platform printing, so I cobbled together a tiny Java program using the print API that I run in the background and pipe data to, and it just works.

all those software already have already proven that.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact