Comment by strictfp | Hacker News Reader

Comment by strictfp | Hacker News Reader

Parent Full thread

Java development scales, it has pretty good performance, and great tooling.

I agree that it's underhyped. You can pick a lot of other languages, but no other language is as broad as Java.

Python reads like a dream but has useless perf and threading.

Javascript (Node et al) has the I/O concurrency but no clear solution to threading, and is bad at number crunching.

C++ has good perf but is overly complicated, compiles take forever, no good module management, etc.

Rust is great but super-hard to learn.

Golang lacks tooling and perhaps some libs, albeit being a really good contender.

Naturally there are other languages to bring up, but I personally think that Java strikes a good balance. The language itself doesn't really have any clear weak points anymore. With lambdas and streams, even FP is succinct in it.

The only thing really speaking against Java right now is the culture of overly complicated frameworks with too much meta-programming and magic. And the fact that the market of lightweight alternatives is too fragmented.

> great tooling

Something I underappreciated until I delved deeper into other languages is how much observability the JVM gives you into how an application is running. Something like VisualVM makes it incredibly easy to see what threads are running, in what state, etc.

There's a class of things where the overhead of a VM (like the JVM, not VMWare) doesn't make sense (kernels, drivers), and startup time can be an issue, but for code where pretty good performance is enough, running in a VM is an asset to me.

This is not Java-specific, though. Tools such as VisualVM are available to all JVM languages.

> Java development scales, it has pretty good performance, and great tooling.

I agree with this, but I think these qualities are shared by a lot of languages that run on the JVM, and Java the language is no longer a worthy flagship language for the JVM.

> With lambdas and streams, even FP is succinct in it.

I have the opposite reaction to lambdas and streams. I think Oracle could have gone two ways with the evolution of Java:

- Be conservative about what features were adopted into Java, but be willing to change the syntax and feel of the language to do it in the best possible way. Only add features that both made sense for Java and had proven themselves after years of experience with the languages that pioneered them, but give Java the most elegant and polished version of them, so that Java would be a kind of "best in class" language that trailed the leading edge but always reflected it in an excellent way -- at any moment, the best version of Java that could be built with the industry's combined experience.

- Or, keep Java feeling as familiar as possible, while adding any features that are embarrassing to lack. It's okay if new features feel bolted on or don't feel as elegant as they do in newer languages; it's more important that longtime Java programmers don't feel like the fundamentals of the language are changing underneath them.

Streams are what convinced me that Oracle were committed to the latter route. They came out with an implementation that looked and felt clunky compared to what people were used to in other languages, but it felt very Java-y, and existing Java developers were pretty immediately comfortable with it.

What about streams is suboptimal? Isn't it just linking together defined lambdas and one-off lambads?

Reply on news.ycombinator.com