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.
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.
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.
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.
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)
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  -- 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.
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.
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.
> 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.
I nominate Spline, best in class skeletal 2D animator.
The Atlantis event display is a visualization program   for the Atlas experiment, the largest, general-purpose particle detector experiment at the Large Hadron Collider (LHC), a particle accelerator at CERN
The Minecraft coding community is amazing. What they get done without documentation is stunning.
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.
Could you provide some more information on what it was not great?
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.
Might as well just use C/C++ instead of fighting the ecosystem tooth and nail.
Do you an example in mind? Unity3D uses C# which is a garbage collected language.
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.
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.
Granted, Maven is an essential piece in the Java ecosystem, yet it seems that many developers are highly opinionated about it.
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.
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.
Android Java is Google's J++, with its half baked Java 8 compatibility, and deserves the same treatment that J++ once had.
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.
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.
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.
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.
That wasn't their intention; Minecraft code was originally obfuscated specifically in order to combat reverse engineering and modification.
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.
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.
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.
* citation needed
The most popular game by player count is CrossFire . 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 ) 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.
(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.
(At least, this was how it was pre-Microsoft. I haven't followed it since then.)
Or did it need the full Java source code to re-mod the program?
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...
Are you serious? Wake us up when somebody implements something as complex and performant as UE4 in Java. Or even UE3 for that matter.
- 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.
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.
And which general purpose language isn't?
The built-in http client library is borderline horrible.
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.
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.
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.
Minecraft was not popular because of Java, Minecraft was popular despite Java.
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?
About your other question: I only mentioned Minecraft.
Not that it was.
Using classes to represent points and vertices instead of arrays, and allocating in hot paths, really?
Netbeans was quite good when I used it as well, although clunkier.
They can be very memory hungry though (of course).
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'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.
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.
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  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  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.
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.
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)
As far as SQL databases go, definitely my best experience, it just works.
Disclosure: I was one of the main people who got Tomcat open sourced.
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 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.
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.
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.
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.
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.
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.
I never knew this was possible
On the other hand, I think server side Java is still great.
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.
This might be confirmation bias, but I actually think it conveys pretty much what it should. :)
> 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.
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.
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.