Tell HN: I kinda want to go back to Java

I’ve never left Java, but it looks like you left before Java 17 which brought a whole lot of nice features compared to 11, and 11 would have just come out when you left.

11 itself had some nice stuff over 8, which I’m guessing may have been what you were on.

Java was the primary programming language of not just my career, but my entire life. It almost feels like comfort food to me.

Though I have moved on to Golang at work & Rust at home, I will always have a soft spot for Java.

Didn't you find the verbose style readable when you opened a project after a long time?

For me the time spent coding is the last step. The more important task is always in identifying a problem worth solving and formulating what I hope to be a coherent design.

The actual typing, while tedious, is the least important part. Just the same, I am sometimes feeding a snippet to a LLM and having it fill out the tedium. Results vary, but the verbose style and longWindedDescriptiveNames seem to help. A few inline comments pick up the rest. The LLM will also expand these into Javadoc type comments.

I've been sort of thinking the same. The Context Dependency Injection stuff was so great, allowed creating things on demand and in different scopes of demands so easily. Jax-rs annotations mostly worked fine & had sufficient hooks to make API writing pretty easy.

I never really was super concerned about verbosity. LLM's should help here yes.

Maven was an interesting blessing and a curse. Theres so many plugins that do so many various things. It took me a lot of my Java career before I stopped trying to find good docs and references & started just diving into the source to see how plugins worked: it freed me from a lot of feelings that everything was mystical & special & showed me many plugins were quite direct & simple, with a few outliers that did ludicrously many things (usually in a bad way).

the top post is pretty vague about what people think they might want or enjoy from Java today. I'd be curious to know more specifics about what folks think are highlights.

Also for the record I left around when java 8 was finalizing, IIRC? Long time.

I’m sorry, you think Python helped us invent LLMs and without it we wouldn’t have? Are you serious right now?

You do realise the Python libraries which work in this space are written in C, right?

Java wasn’t just too verbose, it had bad IDEs and build systems.

If you want to go back, might I suggest Kotlin or C#?

Java doesn't suck anymore. Java 25 will be out this month, try it with a Jetbrains IDE.

My main gripe with Java is not the language, but the organizations that still write their systems in it. I just don't want to go back to working for banks, insurance cos, govt departments.

Same, but I need to circle in on a good framework that is dead simple, not Spring. AOP is not handled well by the LLMs.

The thing is, if you last looked at Java in 2018, prepare for a nice surprise. I mean, we were at version 11 back then, the language has made advances in leaps and bounds.

Just to name a few: half of ML is here (records, pattern matching), we have virtual threads and soon structured concurrency, ZGC, and many more. Project Valhalla (value classes) has been long in the making, hopefully landing in a few years.

Frankly, I had worked with Kotlin and Scala in the past, but nowadays I barely see the need. Yes, Kotlin has if-expressions and null safety and immutable collections, Scala has its type system, but there are also many compromises, and to be honest, these alternatives look less and less appealing as time passes.

I've written a lot of Java in years past but I focus on C# these days. I suggest looking instead at the .NET ecosystem, focused on C# as the language and the huge library support for it - and basically all of it compilable to WASM in the browser via Blazor if you want to do web dev with it instead of JavaScript/Typescript.

At this point, I've used Kotlin longer than I've used Java. There's some new features in Java like nullables, but they're still too verbose. If you like the style of Java with a little functional flavor, Kotlin is about right. If you like the OO stuff, then C# seems to do that better.

Consider Scala rather than Java. After a decade of enterprise Java development I decided to pivot to Scala after seeing the side-by-side code examples in the Play Framework documentation. Scala code is much more succinct and expressive than Java.

The gap has narrowed in recent years, but all the new features of Java have been there for years in Scala, and with neater syntax in Scala. Many Java design patterns are built into the Scala language itself, and the type system is phenomenally powerful. It’s a language where I am constantly learning, even ten years in. It’s wonderful.

Programmed over the years in almost all mainstream programming languages at one time or another.

Saying this, Java was and is in many ways one of the best ecosystems to write software out there, if not the best (when it comes to server side software).

Maven is my favorite build systems so far: Default directory layout means everything has its place, IDEs can easily open any kind of Maven project, and being declarative, one can easily analyze pom.xml files. (I hate writing XML and I still like Maven.)

The next thing is Javas standard library. Well documented and big. Has it better and worse parts? Sure! But what people which never used a language with a good standard library don't get, is that even a bad standard library which is widely used is far better, than the npm-of-the-week clusterfuck, which means that nobody can read three lines of code and really understand, what is happening.

The IDEs are top notch, and you get even free ones (NetBeans, Eclipse) which can rival JetBrains and Visual Studio easily.

... and finally, Java is the only language that I know of, which has multiple strong companies and initiatives behind it, thanks that nobody trusts Oracle (rightfully).

Finally, Java code also got shorter, DI style is IMHO a very good default in any programming language (OOP, FP, Imperative), the community settled mostly on JUnit, so there are never discussions which of the 23 competing test frameworks to use...

In the end, there is a lot of rightful criticism of Java (historical baggage, too late when it comes to AOT, no modern GUI frameworks and a steep learning curve). Java getting new features with the new JDK releases is kind of double edged sword: Many things are good ideas, but they make the language more complicated at the same time.

The verbosity was IMHO never a big thing, because Java was always meant to be used in an IDE, for bigger projects explicit trumps implicit and finally newer revisions introduced stuff like 'var' statements etc.

It is kind of sad, that the Linux community never really jumped/accepted Java for desktop development (which might be explainable, when looking back at the lack of speed of Java in the 90s and the disastrous Solaris Java apps which were simply to slow to be usable).

Anyway, for work I am now using Golang, and it is hilarious how many lessons Golang did not learn from Java, when it comes to language design, although the tooling is top notch and the standard library has at least almost everything needed for writing backend services.

I don't see Java making a comeback, and I don't see anything modern going to replace java at the same time.

Why not consider Clojure?

As a TypeScript lover here are the things I dislike about Java:

* Comparably slow startup. It seems to take so much long to compile the code and startup the JVM for a large application compared to a similar JavaScript/TypeScript application.

* Yes, Java is verbose and that can be annoying but this super low on my list. I can work with this.

* Java forces OOP on you. The original benefit of OOP is efficient memory conservation, but these benefits are lost on garbage collected languages. The primary reason OOP continues to exist is stylistic preference and it’s a preference I don’t like.

* Error states and stack traces feel like a drunk person throwing up. They are all over the place, far too large, and feel like they blame the user for even daring to execute the code.

It’s not all bad. People who write Java seem like they know what they are doing, and I am fully aware this me being naive. Most corporate JavaScript people absolutely have no idea what they are doing. The difference in insecurity and output is strikingly visible from a distance.

I used to do Java about a decade ago and because it was in a corporate environment, add about 5+ years of using outdated Java on top of that. Web applications are what I do, have been doing for 25 years and I use Ruby/Rails now.

I do want to do something meaningful/professional with Go but haven't gotten around to trying it out. I also sort of feel most programming language additions aren't game changers these days. Much like smart phones, the killer feature days are over, small incremental additions are nice.

The killer feature to me is using AI for tedious tasks or syntax I don't remember and in that respect I do wonder if Java would be easier to deal with than what I remember.

I never left, just learned C/C++.

J2ME > J2SE > J2EE (that I never used)

The JVM is the final emulator.

I think everyone should write their own minimal JVM before judging?

I worked briefly with Java/Kotlin a couple of years ago. The language is nice (better than I remembered it). What’s absolutely awful is the build tools around. I hate gradle. It’s overly complicated. The whole bom, settings gradle, build gradle, jars, etc. Nonsense.

I recently joined a company that writes Python after working for a Kotlin shop for the past four years. I miss Java/Kotlin every single day. I have no gripes with Python itself and I enjoy writing it, but I've still never seen a large python codebase that remains as coherent, structured and understandable as the average large JVM language codebase. It's as if the structure of the language itself materially informs the structure of the codebase as it grows.

Java is great right now. Lots of updates, performant, simple language, Intellij is amazing. There is not as much boilerplate as there used to be. All the enterprise stuff has died down quite a bit and you have options now with microframeworks and such.

Java is quite popular, so it's easy to go back. But try C# out. It's years ahead of Java in performance, features, and syntax quality.

I've been doing .NET for years and had to spin up a Java Spring Boot app and it was so painful compared to .NET (esp maven/gradle vs nuget).

This logic makes no sense to me. Names aren't an inherent property of languages; the names you didn't like come from either someone else's "framework" or your own design decisions. Lots of Java code has short names (including single-letter iteration variables), and lots of Python code has long names — for example, the standard library `email.errors` has a class called `InvalidMultipartContentTransferEncodingDefect`. The number of things to name, meanwhile, is purely a consequence of the problem domain, how you model it, and how you factor the code.

"Give me a name for this thing" is the last micro-managing coding task I would assign to an LLM, because the entire point of the name is to express my own intent behind the code.

Besides which, you haven't identified something you actively dislike about Python, just that a problem you supposedly used to experience in Java is supposedly ameliorated now.

Java is an amazing language, but about 4 years ago I moved to Kotlin (back-end): It has all the powerful Java features but it is way simpler to write and also nullability is embedded in the language (no more @NonNull @NotNull Optional<T> stuff). You might find a balance: the power of the JVM and its ecosystem that you can access through a beautiful language that is Kotlin.

> Python helped us invent LLMs - it's quite possible if it didn't exist we would never had invented them.

Sorry, but this is nonsense.

I wish I could write C for $$$. My brain is too fried after work+kid for C. Yesterday I spent a couple hours to write a section of my meter to read literal strings without escaping chars. Should only take some 30m at most.