Java 23: The New Features Are Officially Announced

Original Article ↗ Hacker News Discussion ↗

Java 23’s upcoming features—such as allowing statements before `super()` calls, a Vector API for SIMD operations, and various JVM improvements—are drawing interest but also scrutiny over what is finalized and what has been pulled back, like the current removal of string templates after negative feedback. Commenters debate Java’s evolving feature set and conservative design philosophy against alternatives like C#, Kotlin, Scala, and Go, weighing performance, ecosystem openness, long‑term stability, and developer ergonomics. Several voices also criticize the linked blog post as partly AI-generated and misleading, urging readers to rely on official OpenJDK sources and offering pointers for developers who want to get up to speed with “modern Java.”

Constructor / language changes

  • Many are excited that Java 23 allows statements before super(...), enabling validation or preprocessing before base-class construction.
  • Some argue the original “nothing before super” rule never really prevented constructor footguns, since you could still trigger problematic behavior via field initializers or method calls inside super(...) arguments.
  • Others note that even with the new flexibility, care is still needed to avoid leaking partially constructed this.

Vector API and performance

  • The Vector API is generally viewed positively as a way to access SIMD safely and portably on the JVM.
  • A competing view suggests that if cross-platform SIMD performance is the main goal, .NET’s vectorization APIs and guidance may currently be more mature.

Java vs C#, Kotlin, Scala, others

  • One side claims there is no language-level reason to start new projects in Java instead of C# today; if ecosystem needs allow, other languages may be more attractive.
  • Counterarguments emphasize Java’s balance of performance, productivity, observability, backwards compatibility, and long-term stability for decade‑scale codebases.
  • Debate over .NET: some say it’s now very cross‑platform and often deployed to Linux containers; others distrust Microsoft’s openness and tooling, especially on Linux.

Kotlin and the wider JVM ecosystem

  • One stance: Kotlin is mostly relevant on Android, driven by Google, and won’t “rewrite” the broader Java ecosystem.
  • Others report server‑side shops where virtually all new JVM code is Kotlin, including non‑Android contexts.
  • Reported obstacles to wider Kotlin adoption: slower compilation vs javac, smaller talent pool, single dominant IDE vendor, and Java steadily adopting many of Kotlin/Scala’s most broadly useful features.
  • Supporters still highlight Kotlin’s null safety, concise syntax, context receivers, structured concurrency, and strong Spring Boot integration.

String Templates feature

  • Several commenters are disappointed or confused that the String Templates preview JEP was removed from Java 23 after multiple previews.
  • Links show it was fully backed out from the JDK repo due to largely negative feedback and a planned redesign; it may reappear in a different form in a later release.

Article quality and release status

  • Multiple comments call the article AI‑generated and partially plagiarized (especially from an Infoworld piece), noting nonsensical transitions (e.g., tying super(...) to string templates) and misattributed “beginner‑friendly” claims.
  • The blog’s framing that Java 23 features are “officially announced” is disputed; commenters stress that only the OpenJDK JDK‑23 project page reflects the current, not‑yet‑finalized feature set.