August 29th, 2024

A Java Language Cumulative Feature Rollup

The blog post reviews new Java features since Java 8, detailing enhancements like local-variable type inference, switch expressions, and records, while also noting deprecated APIs, aiding developers in understanding Java's evolution.

Read original articleLink Icon
A Java Language Cumulative Feature Rollup

The blog post from Neward & Associates provides a comprehensive overview of new features introduced in the Java programming language since Java 8. The author compiled a list of enhancements categorized by their respective JDK releases, highlighting significant updates such as the introduction of local-variable type inference in JDK 10, switch expressions in JDK 14, and records in JDK 16. The post also notes the inclusion of various library and virtual machine features, as well as the deprecation and removal of certain APIs and tools over the years. The list serves as a reference for developers seeking to understand the evolution of Java and its capabilities, particularly focusing on features that enhance programming efficiency and performance. The author emphasizes the importance of keeping track of these changes for effective software development.

- The blog lists new Java features introduced since Java 8, categorized by JDK releases.

- Key features include local-variable type inference, switch expressions, and records.

- The post highlights both enhancements and deprecations/removals of APIs and tools.

- It serves as a reference for developers to understand Java's evolution and capabilities.

- The author aims to provide clarity on Java's feature set for improved software development.

Link Icon 5 comments
By @rockyj - 8 months
I'll bite, I tried Java after a while fully open to giving it another shot but ended up being deeply disappointed. It seemed that the language was still stuck in the 90s and features came from the frameworks so there was nothing in the language but all you need to do was learn framework/s and how to use this framework with that library and so on. Storing a date as an ISO UTC by default and sharing it with Json needed layer upon layer of code.

There are no easy ways to build abstractions so it's all annotation upon annotation or back to design patterns of composition / inheritance.

Do not even get me started with Gradle/Maven where declaring a custom task is a mini project.

The language still has old world problems, anything can be null, no easy way for structured concurrency and everything is mutable. Top that with verbosity of using lambda, streams etc and it feels like half of the time in spent in fighting /learning the language or framework and half implementating a feature.

I still think JVM is great, and Kotlin and Clojure offer much more out of the box, but using plain old Java in 2024 is just painful. Most people stick with it because "achitects" (who coded last in 2011) like it and/or people have not tried any other modern programming language and stick with the tried and tested.

By @_old_dude_ - 8 months
I'm using Java Almanac [1].

[1] https://javaalmanac.io/

By @owlstuffing - 8 months
The manifold[1] compiler plugin for java offers a lot of features other languages like Kotlin provide, and innovates in some uniquely awesome ways like type-safe SQL, true delegation, etc.

1. https://github.com/manifold-systems/manifold

By @datavirtue - 8 months
It's good to see Java with this much resources and momentum behind it. Not my first choice of a language but the community has always been solid and I don't have qualms about using it to develop business solutions if that's what everyone wants to use.
By @airstrike - 8 months
I think all JDK links after 10 are 404?