# Java Language

Published articles for Java Language.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Episode 68 "Operator Overloading with Type Classes" \[AtA\]

DevFeed: [Episode 68 "Operator Overloading with Type Classes" \[AtA\]](<https://devfeed.tech/articles/episode-68-operator-overloading-with-type-classes-ata-15128.md>)

Original publisher: [Read original article](<https://inside.java/2026/08/27/podcast-068/>)

Author: Nicolai Parlog

Published: 2026-08-27T00:00:00Z

Content type: article

Language: en

Sources: [Inside Java](<https://devfeed.tech/sources/inside-java.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [openjdk](<https://devfeed.tech/topics/openjdk.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [classes](<https://devfeed.tech/tags/classes.md>), [java](<https://devfeed.tech/tags/java.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [openjdk](<https://devfeed.tech/tags/openjdk.md>), [project-valhalla](<https://devfeed.tech/tags/project-valhalla.md>), [valhalla](<https://devfeed.tech/tags/valhalla.md>)

### AI overview

An Ask the Architects episode discusses how OpenJDK's Project Valhalla is improving Java's support for custom numerical types, including possible limited operator overloading for custom value types.

### Source excerpt

How OpenJDK's Project Valhalla is improving Java's support for custom numerical types.

## Compliance Improvements, Simulator Updates, and More

DevFeed: [Compliance Improvements, Simulator Updates, and More](<https://devfeed.tech/articles/compliance-improvements-simulator-updates-and-more-19266.md>)

Original publisher: [Read original article](<https://www.codenameone.com/blog/compliance-improvements-simulator-updates-and-more/>)

Author: Shai Almog

Published: 2026-04-03T00:00:00Z

Content type: release

Language: en

Sources: [CodeName One](<https://devfeed.tech/sources/codename-one.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Java Language](<https://devfeed.tech/topics/java-language.md>), [Android](<https://devfeed.tech/topics/android.md>), [simulator](<https://devfeed.tech/topics/simulator.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [bug-fixes](<https://devfeed.tech/tags/bug-fixes.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [performance](<https://devfeed.tech/tags/performance.md>), [proguard](<https://devfeed.tech/tags/proguard.md>), [updates](<https://devfeed.tech/tags/updates.md>)

### AI overview

This Codename One update removes Proguard from the build process and replaces it with a custom compliance validator. It also rewrites String.split() calls for consistent simulator and device behavior, expands runtime support, enables newer Java features to remain compatible with Android JDK 17, and updates simulator location support.

### Source excerpt

In todays update were finally removing Proguard from the build process with many implications for all of us.

## Nice and Naughty Cases of Pattern Matching

DevFeed: [Nice and Naughty Cases of Pattern Matching](<https://devfeed.tech/articles/nice-and-naughty-cases-of-pattern-matching-23025.md>)

Original publisher: [Read original article](<https://www.javaadvent.com/2025/12/nice-and-naughty-cases-of-pattern-matching.html>)

Author: Cay Horstmann

Published: 2025-12-08T02:02:26Z

Content type: article

Language: en

Sources: [Java Advent Calendar](<https://devfeed.tech/sources/java-advent-calendar.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [article](<https://devfeed.tech/tags/article.md>), [enums](<https://devfeed.tech/tags/enums.md>), [exhaustive](<https://devfeed.tech/tags/exhaustive.md>), [expression](<https://devfeed.tech/tags/expression.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [java](<https://devfeed.tech/tags/java.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [pattern-matching](<https://devfeed.tech/tags/pattern-matching.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [programming](<https://devfeed.tech/tags/programming.md>), [sealed](<https://devfeed.tech/tags/sealed.md>), [statement](<https://devfeed.tech/tags/statement.md>), [syntax](<https://devfeed.tech/tags/syntax.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

This article examines Java pattern matching in switch and instanceof, explaining when it fits data-oriented programming, when it becomes an antipattern, and how it interacts with legacy behavior. It uses sealed interfaces, records, enums, and JSON values to illustrate exhaustive pattern matching.

### Source excerpt

Since Java 14, the Java switch and instanceof statements have been enhanced, in multiple phases, to support pattern matching and a "data-oriented" programming style. In this article, I explore when this programming style is beneficial, and why. I look at the sweet spot of perfect pattern usage, absolute antipatterns where it should not be used, [...] The post Nice and Naughty Cases of Pattern Matching appeared first on JVM Advent.

## Empowering Your Annotations with Fields

DevFeed: [Empowering Your Annotations with Fields](<https://devfeed.tech/articles/empowering-your-annotations-with-fields-30743.md>)

Original publisher: [Read original article](<http://blog.vanillajava.blog/2024/12/empowering-your-annotations-with-fields.html>)

Author: Peter Lawrey (noreply@blogger.com)

Published: 2024-12-21T22:13:00Z

Content type: tutorial

Language: en

Sources: [Vanilla Java](<https://devfeed.tech/sources/vanilla-java.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Java Language](<https://devfeed.tech/topics/java-language.md>), [Code](<https://devfeed.tech/topics/code.md>), [interfaces](<https://devfeed.tech/topics/interfaces.md>), [enum](<https://devfeed.tech/topics/enum.md>)

Tags: [class](<https://devfeed.tech/tags/class.md>), [code](<https://devfeed.tech/tags/code.md>), [enum](<https://devfeed.tech/tags/enum.md>), [info](<https://devfeed.tech/tags/info.md>), [interfaces](<https://devfeed.tech/tags/interfaces.md>), [java](<https://devfeed.tech/tags/java.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [opinion](<https://devfeed.tech/tags/opinion.md>)

### AI overview

This tutorial explains how Java annotations can contain nested classes, interfaces, enums, other annotations, static fields, and embedded logic. It discusses uses such as domain converters, framework lifecycle hooks, and syntactic sugar, while noting that excessive nesting can reduce readability.

### Source excerpt

Introduction Java's annotation system has come a long way since its introduction in Java 5. At first glance, annotations appear to be mere metadata markers on classes and methods. However, annotations can do much more than that. You can nest types within them, incorporate fields that reference helper classes, and even embed logic via static singletons. These capabilities provide a powerful mechanism for integrating domain-specific or framework-specific functionality right into your code, in ways that are both compact and self-documenting. Why Add Code to Annotations? The Java language specification usually treats annotations as static metadata describing a type, method, field, or parameter. However, you can leverage nested classes (including enums, interfaces, and even other annotations) to extend the functionality of a single annotation. This approach allows you to keep logic closely tied to the metadata, rather than scattering it across multiple classes. Common use cases include: Custom domain converters. For example, if you have a long that needs to be stored in an encoded format (e.g., Base85), you can supply a default converter directly within the annotation. Framework-specific lifecycle hooks. You can embed an interface for processing the annotation, enabling the framework to perform reflective lookups and apply behaviour at runtime. Syntactic sugar. Rather than writing @LongConversion(SomeConverter.class), you could write @ShortText, which internally references a known converter. Nesting Types in Java You can nest various kinds of types within your classes or annotations--these include interfaces, enums, classes, and even other annotations. Although nesting these types can feel unconventional, it is fully supported by the language. For example: public class A { public interface B { public enum C { ; public @interface D { public class E { // etc etc } } } } } While this example might look bizarre, it demonstrates the power and flexibility of Java's nesting rule

## Report card: Java 19 and the end of Kotlin

DevFeed: [Report card: Java 19 and the end of Kotlin](<https://devfeed.tech/articles/report-card-java-19-and-the-end-of-kotlin-20968.md>)

Original publisher: [Read original article](<https://jakewharton.com/report-card-java-19-and-the-end-of-kotlin/>)

Published: 2022-09-20T00:00:00Z

Content type: opinion

Language: en

Sources: [Jake Wharton](<https://devfeed.tech/sources/jake-wharton.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>)

Tags: [developer](<https://devfeed.tech/tags/developer.md>), [feature](<https://devfeed.tech/tags/feature.md>), [future](<https://devfeed.tech/tags/future.md>), [java](<https://devfeed.tech/tags/java.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [jdk](<https://devfeed.tech/tags/jdk.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [project-valhalla](<https://devfeed.tech/tags/project-valhalla.md>), [report](<https://devfeed.tech/tags/report.md>), [update](<https://devfeed.tech/tags/update.md>), [valhalla](<https://devfeed.tech/tags/valhalla.md>)

### AI overview

The article reviews how Java 19 compares with predictions made three years earlier, grading features such as local methods, text blocks, records, sealed hierarchies, type patterns, and virtual threads. It concludes that Java remains strong, Kotlin has continued to evolve, and developers should use the latest JDK rather than wait for an OpenJDK LTS release.

### Source excerpt

Three years ago I gave the talk "What's new in Java 19: The end of Kotlin?" which forecasted what a future Java language would look like in September 2022 when Java 19 was released. Check your calendars, folks. It's September 2022 right now and Java 19 was released today! As expected my predictions were not perfect, but I'm pretty happy with the results. Let's check in with each feature and see how my predictions fared report-card style1. Local methods This feature allows for methods to be declared inside of other methods making them effectively private to that method. public static boolean anyMatch(Graph graph, Predicate<Node> predicate) { var seen = new HashSet<Node>(); boolean hasMatch(Node node) { if (!seen.add(node)) return false; // already seen if (predicate.test(node)) return true; // match! return node.getNodes().stream().anyMatch(n -> hasMatch(n)); } return hasMatch(getRoot()); } Grade: F 🔴 Working support for local methods was added to a branch in Project Amber in October 2019. It seemed like a slam dunk, but a JEP for the feature was never created. The branch still sits in the Project Amber repo unchanged in three years. If I had to guess, all eyes in Amber are focused on pattern matching and its related features. Hopefully someday local methods can be picked back up as a proposed feature. Text blocks A multiline string literal for when one line just isn't enough. System.out.println(""" SELECT * FROM users WHERE name LIKE 'Jake %' """); Grade: A 🟢 Delivered in Java 15. Records A read-only type that exists solely for carrying data with strong, semantic names. record Person(String name, int age) { } Grade: A 🟢 Delivered in Java 16. Sealed hierarchies Define the list of permitted subtypes of your class or interface and prevent any others. sealed interface Developer { } record Person(String name, int age) extends Developer { } record Business(String name) extends Developer { } Grade: A 🟢 Delivered in Java 17. Type patterns Declare a new name to bind when a t

## Constructors Are Not Thread-Safe

DevFeed: [Constructors Are Not Thread-Safe](<https://devfeed.tech/articles/constructors-are-not-thread-safe-32220.md>)

Original publisher: [Read original article](<https://bruceeckel.com/2017/01/13/constructors-are-not-thread-safe/>)

Author: Bruce Eckel

Published: 2017-01-13T00:00:00Z

Content type: tutorial

Language: en

Sources: [Bruce Eckel - Computing Thoughts](<https://devfeed.tech/sources/bruce-eckel-computing-thoughts.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Java](<https://devfeed.tech/topics/java.md>), [Java Language](<https://devfeed.tech/topics/java-language.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [java](<https://devfeed.tech/tags/java.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [locking](<https://devfeed.tech/tags/locking.md>), [object](<https://devfeed.tech/tags/object.md>), [thread](<https://devfeed.tech/tags/thread.md>), [threads](<https://devfeed.tech/tags/threads.md>)

### AI overview

This Java article explains why object construction is not automatically thread-safe. It examines shared mutable state, concurrent object creation, constructor arguments, synchronization, and factory methods as ways to avoid collisions and ensure safe construction.

### Source excerpt

When you imagine the construction process, it can be easy to think that it's thread-safe. After all, no one can even see the new object before it finishes initialization, so how could there be contention over that object? Indeed, the Java Language Specification (JLS) confidently states: "There is no practical need for a constructor to be synchronized, because it would lock the object under construction, which is normally not made available to other threads until all constructors for the object have completed their work.

## Var and val in Java?

DevFeed: [Var and val in Java?](<https://devfeed.tech/articles/var-and-val-in-java-21990.md>)

Original publisher: [Read original article](<http://blog.joda.org/2016/03/var-and-val-in-java.html>)

Author: Stephen Colebourne (noreply@blogger.com)

Published: 2016-03-26T00:04:00Z

Content type: opinion

Language: en

Sources: [Stephen Colebourne](<https://devfeed.tech/sources/stephen-colebourne.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Java Language](<https://devfeed.tech/topics/java-language.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>), [code productivity](<https://devfeed.tech/topics/code-productivity.md>)

Tags: [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [coding](<https://devfeed.tech/tags/coding.md>), [developer-experience](<https://devfeed.tech/tags/developer-experience.md>), [java](<https://devfeed.tech/tags/java.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [java9](<https://devfeed.tech/tags/java9.md>), [val](<https://devfeed.tech/tags/val.md>), [var](<https://devfeed.tech/tags/var.md>)

### AI overview

This opinion examines proposed local variable type inference for Java under JEP-286, including the possible use of var, val, or let. It argues that the feature could reduce Java's verbosity while making some code reviews harder, and considers Java's history when evaluating the keyword choice.

### Source excerpt

Should local variable type inference be added to Java? This is the question being pondered right now by the Java language team. Local Variable Type Inference JEP-286 proposes to add inference to local variables using a new psuedo-keyword (treated as a "reserved type name"). We seek to improve the developer experience by reducing the ceremony associated with writing Java code, while maintaining Java's commitment to static type safety, by allowing developers to elide the often-unnecessary manifest declaration of local variable types. A number of possible keywords have been suggested: var - for mutable local variables val - for final (immutable) local variables let - for final (immutable) local variables auto - well lets ignore that one shall we... Given the implementation strategy, it appears that the current final keyword will still be accepted in front of all of the options, and thus all of these would be final (immutable) variables: final var - changes the mutable local variable to be final final val - redundant additional modifier final let - redundant additional modifier Thus, the choice appears to be to add one of these combinations to Java: var and final var var and val - but final var and final val also valid var and let - but final var and final let also valid In broad terms, I am unexcited by this feature and unconvinced it actually makes Java better. While IDEs can mitigate the loss of type information when coding, I expect some code reviews to be significantly harder (as they are done outside IDEs). It should also be noted that the C# coding standards warn against excessive use of this feature: Do not use var when the type is not apparent from the right side of the assignment. Do not rely on the variable name to specify the type of the variable. It might not be correct. Having said the above, I suspect there is very little chance of stopping this feature. The rest of this blog post focuses on choosing the right option for Java Best option for Java When thi

## Balancing Uncertainty Through Java Programming Projects

DevFeed: [Balancing Uncertainty Through Java Programming Projects](<https://devfeed.tech/articles/finding-flow-32193.md>)

Original publisher: [Read original article](<https://bruceeckel.com/2014/11/18/finding-flow/>)

Author: Bruce Eckel

Published: 2014-11-18T00:00:00Z

Content type: opinion

Language: en

Sources: [Bruce Eckel - Computing Thoughts](<https://devfeed.tech/sources/bruce-eckel-computing-thoughts.md>)

Topics: [Java Language](<https://devfeed.tech/topics/java-language.md>), [Java](<https://devfeed.tech/topics/java.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>)

Tags: [experiment](<https://devfeed.tech/tags/experiment.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [java](<https://devfeed.tech/tags/java.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

The author reflects on using concrete programming projects to balance uncertainty and find a sense of flow. They consider revisiting Thinking in Java by updating it for Java 8, replacing Ant with Gradle, and selecting useful features and libraries while avoiding an overly broad treatment of the language.

### Source excerpt

(This post is an experiment to test a new blogging platform. This version is just straight out of MarkdownPad into Github pages, with no other software on my local machine) Balancing Uncertainty via Concrete Projects The Reinventing Business project is my "own personal Everest to climb," my project that, once I saw it, I couldn't unsee. It's also very unclear whether I will ever make any significant breakthroughs in that area.

## Introducing Wire Protocol Buffers

DevFeed: [Introducing Wire Protocol Buffers](<https://devfeed.tech/articles/introducing-wire-protocol-buffers-15721.md>)

Original publisher: [Read original article](<https://developer.squareup.com/blog/introducing-wire-protocol-buffers>)

Author: Square Engineering

Published: 2013-08-23T16:04:00Z

Content type: release

Language: en

Sources: [Square Corner Blog RSS Feed](<https://devfeed.tech/sources/square-corner-blog-rss-feed.md>)

Topics: [Protocol (disambiguation)](<https://devfeed.tech/topics/protocol.md>), [Android](<https://devfeed.tech/topics/android.md>), [Library](<https://devfeed.tech/topics/library.md>), [Java](<https://devfeed.tech/topics/java.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [code](<https://devfeed.tech/tags/code.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [java-language](<https://devfeed.tech/tags/java-language.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [protocol](<https://devfeed.tech/tags/protocol.md>)

### AI overview

Square introduces Wire, a lightweight, open-source implementation of Google's Protocol Buffers for Android and other Java environments. The library was created to provide compact, readable, deeply immutable generated data objects with features such as meaningful equals, hashCode, and toString methods, chained builders, and Java enum support.

### Source excerpt

A new, lightweight implementation of Protocol Buffers for Android.