Nothing wrong with Java or JVM based languages. They're just not the shiny new thing anymore.

I don't know what kind of software you write at your company. It could be that the JVM was a poor fit for the stuff you do and Rust is far more suited. Or it could just be someone in leadership read a blog post where some company migrated from Java to Rust and saw a billion percent perf increase despite their use case being specific and not at all applicable to what you do and decided to decree that everything gets ported to Rust.... or any dozen of reasons in-between

Java is fine, especially if you use a modern version or Scala/Kotlin. If you're talking about migrating to Rust specifically, it's probably because Rust can do a lot of things that people used to reach to Java for, with zero-cost abstractions. (The most obvious obviously being garbage collection.) Secondly, Java's performance for a running application is best-in-class for a dynamic, GCed language, but it still has a notoriously slow startup time. This makes it unsuitable for some use cases, where Rust might be a better option. (The tradeoff is probably that Java runs on more platforms with one executable.)

Java has never had a good reputation, lol. But seriously, by every possible measure it has superior competitors:

• Compared to dynamically-typed or interpreted languages, Java performs better, but it requires a frankly ludicrous amount of extra typing.
• Compared to AOT compiled languages, it performs poorly except in purely numeric code where it has the advantage of portable -march=native. Other code almost never can be optimized due to the mandatory memory overhead.
• Compared to any language, Java lacks support for most forms of ownership that people actually intend, and makes them very difficult to implement them yourself. Of the 3 ownership policies it does support, GC is useless (solely a crutch for programmers who are too lazy or too incompetent to specify what they want), Weak is sabotaged by its relation to GC, and Unique is limited to local contexts and does not compose. (I don't consider Phantom and Soft to actually be distinct ownership types, just hooks for GC ownership)
• In its own niche (static types + JIT + GC), C# is strictly superior as a language, due to supporting value types (although not all C# bothers to use them, at least you have the option of performance). The only disadvantage of C# is in its ecosystem: historically there were a lot of Windows-only libraries; also there were people specifically depending on Java's ecosystem.

Writing your new app in Java is still better than using Electron or something though.

Started? Java has had a bad reputation since its inception. Slow startup, memory hungry, verbose. The main benefits of Java were its WORA mindset and its memory safety.

Rust takes that safety even further, plus it's making inroads in places Java would fall flat. For example, the M1 video drivers for Linux are written in Rust.

I personally can't wrap my mind around Rust's memory model.. Java is far easier to understand. That said, Rust certainly has momentum that I haven't seen since Java replaced Scheme in every university's CS101.

Ever since Oracle accuired Java, it got bit annoying in some parts. Of course there are now milllion plus one open source Java JDK/JRE implementations, but it adds another level of complexity.

Previously it was Sun Java, and everyone used that, which was clear.

Now compability between JDK's is like "sure, SHOULD work, but no quarantee"

Java is improving rapidly. As is the JVM. They are both quality tools that might be the right tools.

I don't program in Java but I do Scala and am familiar with the JVM. The JVM is hard to beat for observability and predictability. Businesses love predictability. Especially enterprise. "500k more? But predictable? Fuck yes." See also: backwards compatibility.

That said the JVM needs to change. Check out the project Valhalla blogs. At the same time the science and engineering of building languages and systems has improved. "New" does not carry the same risk as what the 00s would lead one to believe.

Memory safety is a huge value. I'm sticking to Scala - more my style. Rust is memory safe and native. Which is kinda fucking awesome. So I can see the appeal.

Tl;Dr. Java bad? No.

I believe it is just an inclination to use Rust. A lot of companies still use java and one of the reasons being oracle is shitty with the terms, but compiled languages like rust are greater choices than java in terms of speed and efficiency.

So Java is kinda slow. Its "everything is a class" mentality has lost favor as first-class functions have become popular through languages like JavaScript (no relation to Java) and Python. Even C++ has them now.

Independent of the language itself, Oracle (the company that owns Java) has become unpopular in the industry recently as they changed the way the Java Development Kit was licensed, making it significantly more expensive, and for being on the wrong side of the Google v. Oracle suit. (Literally everyone, from the OSF and the EFF to the "big five" tech companies took Google's side.)

I am jealous of your job

Java is an okay language, but your shop is probably switching, because Oracle changed up the licensing for Java to rake in more money from companies that can't switch.

It's really a question you should be asking someone in your company. There is no general answer to this question, and every company has it's own reasons for doing something like this. It could be that the CTO is a moron and wasting engineering time chasing a fad, it could be that staying on Java presents some sort of risk to the company, it could be that Java simply isn't a good fit for the problems the company is solving, there are a million reasons for doing something like this. It doesn't necessarily mean that Java is bad, just that Java isn't really fit for the company's purpose.

Java is fine, what do you think is wrong with it? You'd have to say why they're switching to Rust, without the details we can't say if it seems right or wrong.

The JVM is a beast, and it's very inefficient with memory esp strings.

I'm just here to shill for Kotlin because, for non-performance critical applications (and notice I didn't say non-performant!), the JVM can still be an excellent platform.

And while Java still has many of its old 'faults' (a question of opinion, I suppose), it also has come a long way with many cool new features. But yeah, Kotlin really just hits it out of the park, I really want to encourage people to give it a try!

Did you not ask anyone in your company why they're making the switch?

What makes you think it's bad reputation in California?

Ah nice to hear, people come to sanity in your company :X

I've programmed in all kinds of languages and Java (and the likes like C# IMHO) often felt like programming boilerplate all the way (spoiler: I don't like OOP, why should I ever need an abstract factory? And I never understand why error handling needs to be done with exceptions, just use return values monadic style). The type-system, composability and power that Rust has, is IMHO unparalleled (the combination, there are languages for each of these topics that are more powerful I think).

JVM is just outdated IMHO (I don't want to list the reasons why JVM is bad, that is googleable, but one thing I don't like much is lack of monomorphisation and integration into the web), I think Rust shows that a GC is not necessary for having a nice-to-use high-level crossplatform language (even frontend web is working remarkably well).