# Java Language

Java is a general-purpose, concurrent, class-based, object-oriented programming 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.

## 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.

## 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

## ToastBar Return Value

DevFeed: [ToastBar Return Value](<https://devfeed.tech/articles/toastbar-return-value-19616.md>)

Original publisher: [Read original article](<https://www.codenameone.com/blog/toastbar-return-value/>)

Author: Shai Almog

Published: 2018-06-25T00: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>)

Tags: [bytecode](<https://devfeed.tech/tags/bytecode.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [java](<https://devfeed.tech/tags/java.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [language](<https://devfeed.tech/tags/language.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

An enhancement changed ToastBar static showMessage methods to return a Status object instead of void, enabling more control after displaying a toast. Because Java return types contribute to method signatures, the change can break binary compatibility for users compiled against older libraries. Updating client libraries and performing a clean build is recommended before sending a new build.

### Source excerpt

Last week I pushed out an enhancement to ToastBar that changed the static showMessage methods. I made them return the Status object instead of void which would allow more control of the toast message after it's shown. Unfortunately, I totally forgot that I can't do that without breaking some binary compatibility. In Java return types create a distinct method signature, so even though the language doesn't allow you to do this:

## 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.

## Satirical announcement about modifying access modifiers in open-source Java projects

DevFeed: [Satirical announcement about modifying access modifiers in open-source Java projects](<https://devfeed.tech/articles/wikileaks-to-leak-5000-open-source-java-projects-with-all-that-private-final-bullshit-removed-38773.md>)

Original publisher: [Read original article](<https://steve-yegge.blogspot.com/2010/07/wikileaks-to-leak-5000-open-source-java.html>)

Author: Steve Yegge (noreply@blogger.com)

Published: 2010-07-28T20:40:00Z

Content type: opinion

Language: en

Sources: [Steve Yegge](<https://devfeed.tech/sources/steve-yegge.md>)

Topics: [Java](<https://devfeed.tech/topics/java.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Code](<https://devfeed.tech/topics/code.md>), [Java Language](<https://devfeed.tech/topics/java-language.md>), [class](<https://devfeed.tech/topics/class.md>), [constructor](<https://devfeed.tech/topics/constructor.md>), [deprecated](<https://devfeed.tech/topics/deprecated.md>), [Perl](<https://devfeed.tech/topics/perl.md>)

Tags: [class](<https://devfeed.tech/tags/class.md>), [code](<https://devfeed.tech/tags/code.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [deprecated](<https://devfeed.tech/tags/deprecated.md>), [java](<https://devfeed.tech/tags/java.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [perl](<https://devfeed.tech/tags/perl.md>), [projects](<https://devfeed.tech/tags/projects.md>), [source](<https://devfeed.tech/tags/source.md>)

### AI overview

This satirical article describes a purported Wikileaks announcement to re-release open-source Java projects after changing access modifiers, removing most final and deprecated declarations, adding public constructors, and exposing fields.

### Source excerpt

EYJAFJÖLL, ICELAND -- Java programmers around the globe are in a panic today over a Wikileaks press release issued at 8:15am GMT. Wikileaks announced that they will re-release the source code for thousands of Open Source Java projects, making all access modifiers 'public' and all classes and members non-'final'. Agile Java Developer Johnnie Garza of Irvine, CA condemns the move. "They have no right to do this. Open Source does not mean the source is somehow 'open'. That's my code, not theirs. If I make something private, it means that no matter how desperately you need to call it, I should be able to prevent you from doing so, even long after I've gone to the grave." According to the Wikileaks press release, millions of Java source files have been run through a Perl script that removes all 'final' keywords except those required for hacking around the 15-year-old Java language's "fucking embarrassing lack of closures." Moreover, the Perl script gives every Java class at least one public constructor, and turns all fields without getters/setters into public fields. "The script yanks out all that @deprecated shit, too," claims the controversial announcement. Longtime Java programmer Ronnie Lloyd of Austin, TX is offended by the thought of people instantiating his private classes. "It's just common sense," said Lloyd, who is 37. "If I buy you a house and put the title in your name, but I mark some of the doors 'Employees Only', then you're not allowed to open those doors, even though it's your house. Because it's really my house, even though I gave it to you to live in." Pacing and frowning thoughtfully, Lloyd continued: "Even if I go away forever and you live there for 20 years and you know exactly what's behind the doors -- heck, even if it's a matter of life and death -- plain old common sense still dictates that you're never, ever allowed to open them for any reason." "It's for your own protection," Lloyd added. Wesley Doyle, a Java web developer in Toronto, Canada is m