Month: May 2024

Article originally posted on InfoQ. Visit InfoQ

The US National Institute of Standards and Technology (NIST) launched a public generative AI evaluation program developed by the international research community. The pilot program focuses on text-to-text and text-to-image. The general objectives include but are not limited to evolving benchmark dataset creation, multi-modal authenticity detection, comparative analysis and fake or misinformation source detection. The first-round submission deadline is August.

The pilot aims to measure and understand system behaviours for discriminating between synthetic and human-generated content in text-to-text (T2T) and text-to-image (T2I) modalities. Mainly, to respond to the following: “How does human content differ from synthetic content?” and “How can users differentiate between the two?”

Teams can act as generators, discriminators or both. Generator teams will be evaluated on their system’s ability to generate synthetic content as close as possible to humans. The discriminator teams will be evaluated on their system’s ability to detect synthetic content created by generative AI (LLMs and deep fake tools).

The Text-To-Text-Discriminators (T2T-D) task will need to detect whether a targeted output summary was generated using generative AI. Each trial consists of a single summary, the T2T-D detection system must render a confidence score (any real number). The higher numbers indicating the target text summary is more likely to have been generated using LLM-based models. The primary metric for measuring detection performance will be the Area Under the Receiver Operating Characteristics (ROC) Curve (AUC).

The Text-to-Text Generators (T2T-G) task is designed to automatically generate high-quality summaries based on a “topic” (statement of information needed) and a set of targeted documents (about 25). The summary must answer the need for information expressed in the topic statement. Participants should assume that the target audience of the summary is a supervisory information analyst who will use it to inform decision-making. The submission will have to adhere to the following rules:

• All processing of documents and generation of summaries must be automatic
• The summary can be no longer than 250 words (whitespace-delimited tokens)
• Summaries longer than the size limit will be truncated
• No bonus will be given for creating shorter summaries
• No specific formatting other than linear is allowed (e.g. plain text)

There will be about 45 topics in the test data for generator teams. This set of summaries from all generator teams will serve as the testing data for discriminator teams. The summary output will be evaluated by determining how easy or difficult it is to discriminate AI-generated summaries from human-generated summaries (the goal of generators is to output a summary that is indistinguishable from human-generated summaries).

The participants are not allowed to use the test dataset for training, modelling, or tuning their algorithms. All machine learning or statistical analysis algorithms must complete training, model selection, and tuning before running their system on the available test data; learning/adaptation during processing is not permissible. Each participant is allowed to submit system output for evaluation only once per 24-hour period.

The first pilot is focused on text-to-text and it will run throughout 2024. The platform is designed to support multiple modalities and technologies for teams from academia, industry, and other research labs. Those interested in participating can register on the program’s website until May 2025. The test phases are scheduled in June, September and November. After the evaluation closes in January 2025, the results will be released in February 2025 and a GenAI evaluation workshop will be organised in March 2025.

Other such contests are the generative AI hackathon organised by Google, the RTX developer challenge proposed by Nvidia, the generative AI competition organised by members from Harvard and AI for Life Sciences organised with support from the University of Vienna.

Article originally posted on InfoQ. Visit InfoQ

The US National Institute of Standards and Technology (NIST) launched a public generative AI evaluation program developed by the international research community. The pilot program focuses on text-to-text and text-to-image. The general objectives include but are not limited to evolving benchmark dataset creation, multi-modal authenticity detection, comparative analysis and fake or misinformation source detection. The first-round submission deadline is August.

The pilot aims to measure and understand system behaviours for discriminating between synthetic and human-generated content in text-to-text (T2T) and text-to-image (T2I) modalities. Mainly, to respond to the following: “How does human content differ from synthetic content?” and “How can users differentiate between the two?”

Teams can act as generators, discriminators or both. Generator teams will be evaluated on their system’s ability to generate synthetic content as close as possible to humans. The discriminator teams will be evaluated on their system’s ability to detect synthetic content created by generative AI (LLMs and deep fake tools).

The Text-To-Text-Discriminators (T2T-D) task will need to detect whether a targeted output summary was generated using generative AI. Each trial consists of a single summary, the T2T-D detection system must render a confidence score (any real number). The higher numbers indicating the target text summary is more likely to have been generated using LLM-based models. The primary metric for measuring detection performance will be the Area Under the Receiver Operating Characteristics (ROC) Curve (AUC).

The Text-to-Text Generators (T2T-G) task is designed to automatically generate high-quality summaries based on a “topic” (statement of information needed) and a set of targeted documents (about 25). The summary must answer the need for information expressed in the topic statement. Participants should assume that the target audience of the summary is a supervisory information analyst who will use it to inform decision-making. The submission will have to adhere to the following rules:

• All processing of documents and generation of summaries must be automatic
• The summary can be no longer than 250 words (whitespace-delimited tokens)
• Summaries longer than the size limit will be truncated
• No bonus will be given for creating shorter summaries
• No specific formatting other than linear is allowed (e.g. plain text)

There will be about 45 topics in the test data for generator teams. This set of summaries from all generator teams will serve as the testing data for discriminator teams. The summary output will be evaluated by determining how easy or difficult it is to discriminate AI-generated summaries from human-generated summaries (the goal of generators is to output a summary that is indistinguishable from human-generated summaries).

The participants are not allowed to use the test dataset for training, modelling, or tuning their algorithms. All machine learning or statistical analysis algorithms must complete training, model selection, and tuning before running their system on the available test data; learning/adaptation during processing is not permissible. Each participant is allowed to submit system output for evaluation only once per 24-hour period.

The first pilot is focused on text-to-text and it will run throughout 2024. The platform is designed to support multiple modalities and technologies for teams from academia, industry, and other research labs. Those interested in participating can register on the program’s website until May 2025. The test phases are scheduled in June, September and November. After the evaluation closes in January 2025, the results will be released in February 2025 and a GenAI evaluation workshop will be organised in March 2025.

Other such contests are the generative AI hackathon organised by Google, the RTX developer challenge proposed by Nvidia, the generative AI competition organised by members from Harvard and AI for Life Sciences organised with support from the University of Vienna.

Article originally posted on InfoQ. Visit InfoQ

JetBrains has released Kotlin 2.0 along with the new K2 compiler. While the language itself introduces no new syntax, the K2 compiler brings several benefits, including faster builds, extended language capabilities with smart casts, and multiplatform support out of the box.

This release introduces the K2 compiler, unifying all platforms that Kotlin supports, as all compiler backends now share a lot of logic and a unified pipeline. This allows us to implement most features, optimizations, and bug fixes once for all platforms, drastically increasing the development speed of new language features.

K2 currently supports four backends: JVM, JavaScript, Wasm, and native. One of the benefits of targeting all platforms through the same compiler is the possibility to support multiplatform library development easily through the definition of a new format for multi-platform library distribution which will enable the creation of universal Kotlin libraries from any host.

Additionally, as Michail Zarečenskij explained in his Kotlin 2.0 talk at the Kotlin 2024 Conference, multiplatform support came about piecemeal, which made support for the different platforms hard to maintain and evolve.

On the performance front, K2 significantly speeds up compilation time for real world project. JetBrains says K2 doubles compilation speed on the average, with some project compiling faster and others compiling slower than that. The speedup is mostly related to improvement in the initialization phase, which is up to 488% faster, and the analysis phase, which is up to 376% quicker.

Besides performance and multiplatform support, another key reason to switch to a new compiler was to make the language smarter when interpreting developers’ intentions with their code.

This was achieved by making the Frontend Intermediate Representation (FIR) support earlier desugaring, so the compiler has more chances to analyze the code; implementing a phased approach to analysis across imports, annotations, and types, which brings more opportunities to integrate IDEs and compiler plugins; and bringing in a new control flow engine with improvements to type inference and resolution. The new control flow engine helps detect unusual code, bugs and other potential issues, thus contributing to the language safety.

As a point in case for the improvements to the language expressivenes these changes bring, Kotlin 2.0 now better supports combinations of operators and numeric conversions. For example, the statement longList[0] += 1 is now allowed and also works in combination with nullable values and the optional dereferencing operator ?.

Control flow is one of the main task of developers today, says Zarečenskij. This is the reason why JetBrains focused on extending the capabilities of the language (syntax) to inspect data and describe conditions, with the effect of improving readability and removing layers of nesting. Additionally, he says, smart casts reduce cognitive load since you do not need to learn new constructs.

For example Kotlin 2.0 will propagate a smart cast on a local variable as in the following example:

fun petAnimal(animal: Any) {
    if (animal is Cat) {
        animal.purr()
    }
}

Likewise, smart casts will be propagated to save the state about nullability, is-checks, as-casts and contracts.

Another case when Kotlin 2.0 applies new smart cast is with variables captured inside closures as read/write. In this case,

Kotlin will continue enhancing its control flow engine by adding features like pattern matching without binding, context-sensitive resolution, generalized ADTs to support even more smart casts, an effect system, and more.

Many of these new features are in the language roadmap for Kotlin 2.1 or 2.2. Covering all of the newly announced features goes beyond the scope of this article, so do not miss talk at the Kotlin 2024 Conference for the full detail.

Article originally posted on InfoQ. Visit InfoQ

JetBrains has released Kotlin 2.0 along with the new K2 compiler. While the language itself introduces no new syntax, the K2 compiler brings several benefits, including faster builds, extended language capabilities with smart casts, and multiplatform support out of the box.

This release introduces the K2 compiler, unifying all platforms that Kotlin supports, as all compiler backends now share a lot of logic and a unified pipeline. This allows us to implement most features, optimizations, and bug fixes once for all platforms, drastically increasing the development speed of new language features.

K2 currently supports four backends: JVM, JavaScript, Wasm, and native. One of the benefits of targeting all platforms through the same compiler is the possibility to support multiplatform library development easily through the definition of a new format for multi-platform library distribution which will enable the creation of universal Kotlin libraries from any host.

Additionally, as Michail Zarečenskij explained in his Kotlin 2.0 talk at the Kotlin 2024 Conference, multiplatform support came about piecemeal, which made support for the different platforms hard to maintain and evolve.

On the performance front, K2 significantly speeds up compilation time for real world project. JetBrains says K2 doubles compilation speed on the average, with some project compiling faster and others compiling slower than that. The speedup is mostly related to improvement in the initialization phase, which is up to 488% faster, and the analysis phase, which is up to 376% quicker.

Besides performance and multiplatform support, another key reason to switch to a new compiler was to make the language smarter when interpreting developers’ intentions with their code.

This was achieved by making the Frontend Intermediate Representation (FIR) support earlier desugaring, so the compiler has more chances to analyze the code; implementing a phased approach to analysis across imports, annotations, and types, which brings more opportunities to integrate IDEs and compiler plugins; and bringing in a new control flow engine with improvements to type inference and resolution. The new control flow engine helps detect unusual code, bugs and other potential issues, thus contributing to the language safety.

As a point in case for the improvements to the language expressivenes these changes bring, Kotlin 2.0 now better supports combinations of operators and numeric conversions. For example, the statement longList[0] += 1 is now allowed and also works in combination with nullable values and the optional dereferencing operator ?.

Control flow is one of the main task of developers today, says Zarečenskij. This is the reason why JetBrains focused on extending the capabilities of the language (syntax) to inspect data and describe conditions, with the effect of improving readability and removing layers of nesting. Additionally, he says, smart casts reduce cognitive load since you do not need to learn new constructs.

For example Kotlin 2.0 will propagate a smart cast on a local variable as in the following example:

fun petAnimal(animal: Any) {
    if (animal is Cat) {
        animal.purr()
    }
}

Likewise, smart casts will be propagated to save the state about nullability, is-checks, as-casts and contracts.

Another case when Kotlin 2.0 applies new smart cast is with variables captured inside closures as read/write. In this case,

Kotlin will continue enhancing its control flow engine by adding features like pattern matching without binding, context-sensitive resolution, generalized ADTs to support even more smart casts, an effect system, and more.

Many of these new features are in the language roadmap for Kotlin 2.1 or 2.2. Covering all of the newly announced features goes beyond the scope of this article, so do not miss talk at the Kotlin 2024 Conference for the full detail.

Article originally posted on InfoQ. Visit InfoQ

This week’s Java roundup for May 20th, 2024 features news highlighting: Java’s 29th birthday; the release of Kotlin 2.0 and Semantic Kernel for Java 1.0; JEP 477, Implicitly Declared Classes and Instance Main Methods (Third Preview), targeted for JDK 23; and four JEPs proposed to target for JDK 23

Java Turns 29

On May 23rd, 1995, Java 1.0 was introduced to developers who attended the Sun World ‘95 conference. A Java community was born and 29 years later, the community has evolved to include 370 global Java User Groups, 370 Java Champions and many Java-related conferences in a given calendar year. There have been 22 formal releases

At Devnexus 2024, Sharat Chander, Senior Director, Product Management & Developer Engagement at Oracle, announced that JavaOne will return to celebrate Java’s 30th birthday. It will be held March 17-20, 2025 in Redwood Shores, California. Please stay tuned for the call for papers.

OpenJDK

After its review has concluded, JEP 477, Implicitly Declared Classes and Instance Main Methods (Third Preview), has been promoted from Proposed to Target to Targeted for JDK 23. Formerly known as Unnamed Classes and Instance Main Methods (Preview), Flexible Main Methods and Anonymous Main Classes (Preview) and Implicit Classes and Enhanced Main Methods (Preview), this JEP incorporates enhancements in response to feedback from the two previous rounds of preview, namely JEP 463, Implicit Classes and Instance Main Methods (Second Preview), delivered in JDK 22, and JEP 445, Unnamed Classes and Instance Main Methods (Preview), delivered in JDK 21. This JEP proposes to “evolve the Java language so that students can write their first programs without needing to understand language features designed for large programs.” This JEP moves forward the September 2022 blog post, Paving the on-ramp, by Brian Goetz, Java Language Architect at Oracle. The latest draft of the specification document by Gavin Bierman, Consulting Member of Technical Staff at Oracle, is open for review by the Java community. More details on JEP 445 may be found in this InfoQ news story.

JEP 482, Flexible Constructor Bodies (Second Preview), has been promoted from Candidate to Proposed to Target for JDK 23. This JEP proposes a second round of preview and a name change to obtain feedback from the previous round of preview, namely JEP 447, Statements before super(…) (Preview), delivered in JDK 22. This feature allows statements that do not reference an instance being created to appear before the this() or super() calls in a constructor; and preserve existing safety and initialization guarantees for constructors. Changes in this JEP include: a treatment of local classes; and a relaxation of the restriction that fields can not be accessed before an explicit constructor invocation to a requirement that fields can not be read before an explicit constructor invocation. Gavin Bierman, Consulting Member of Technical Staff at Oracle, has provided an initial specification of this JEP for the Java community to review and provide feedback. The review is expected to conclude on May 27, 2024.

JEP 481, Scoped Values (Third Preview), has been promoted from Candidate to Proposed to Target for JDK 23. Formerly known as Extent-Local Variables (Incubator), this JEP proposes a third preview, with one change, in order to gain additional experience and feedback from one round of incubation and two rounds of preview, namely: JEP 464, Scoped Values (Second Preview), delivered in JDK 22; JEP 446, Scoped Values (Preview), delivered in JDK 21; and JEP 429, Scoped Values (Incubator), delivered in JDK 20. This feature enables sharing of immutable data within and across threads. This is preferred to thread-local variables, especially when using large numbers of virtual threads. The change in this feature is related to the operation parameter of the callWhere() method, defined in the ScopedValue class, is now a functional interface which allows the Java compiler to infer whether a checked exception might be thrown. With this change, the getWhere() method is no longer needed and has been removed. The review is expected to conclude on May 29, 2024

JEP 480, Structured Concurrency (Third Preview), has been promoted from Candidate to Proposed to Target for JDK 23. This JEP proposes a third preview, without change, in order to gain more feedback from the previous two rounds of preview, namely: JEP 462, Structured Concurrency (Second Preview), delivered in JDK 22; and JEP 453, Structured Concurrency (Preview), delivered in JDK 21. This feature simplifies concurrent programming by introducing structured concurrency to “treat groups of related tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability.” The review is expected to conclude on May 27, 2024.

JEP 471, Deprecate the Memory-Access Methods in sun.misc.Unsafe for Removal, has been promoted from Candidate to Proposed to Target for JDK 23. This JEP proposes to deprecate the memory access methods in the Unsafe class for removal in a future release. These unsupported methods have been superseded by standard APIs, namely; JEP 193, Variable Handles, delivered in JDK 9; and JEP 454, Foreign Function & Memory API, delivered in JDK 22. The review is expected to conclude on May 27, 2024.

JDK 23

Build 24 of the JDK 23 early-access builds was made available this past week featuring updates from Build 23 that include fixes for various issues. Further details on this release may be found in the release notes.

Jakarta EE 11

In his weekly Hashtag Jakarta EE blog, Ivar Grimstad, Jakarta EE Developer Advocate at the Eclipse Foundation, has provided an update on the upcoming GA release of Jakarta EE 11. Nine (9) specifications, namely – Jakarta Annotations 3.0, Jakarta Authorization 3.0, Jakarta Contexts and Dependency Injection 4.1, Jakarta Expression Language 6.0, Jakarta Interceptors 2.2, Jakarta RESTful Web Services 4.0, Jakarta Persistence 3.2, Jakarta Validation 3.1 and Jakarta WebSocket 2.2 – have been finalized for Jakarta EE 11. The remaining seven (7) updated specifications are in various stages of review.

Spring Framework

It was a busy week over at Spring as the various teams have delivered numerous milestone and point releases on Spring Boot, Spring Framework, Spring Cloud Data Flow, Spring Security, Spring Authorization Server, Spring for GraphQL, Spring Session, Spring Integration, Spring Modulith, Spring Batch, Spring AMQP, Spring for Apache Kafka and Spring for Apache Pulsar. More details may be found in this InfoQ news story.

Kotlin

JetBrains has released version 2.0 of Kotlin that finalizes the new frontend for the Kotlin compiler, codenamed K2, to unify all supported Kotlin platforms by which all compiler backends now share a significant amount of logic and a unified pipeline. Kotlin 2.0 promises faster compilation speed and support for Compose Multiplatform projects. JetBrains has also been developing a K2 Kotlin Mode, currently in alpha, for IntelliJ IDEA. Further details on this release may be found in the what’s new page. InfoQ will follow up with a more detailed news story.

Quarkus

Quarkus 3.10.2, the second maintenance release, ships with notable changes such as: a resolution to a QuarkusErrorHandler runtime error upon invoking a REST client endpoint that accepts a @BeanParam on a bean containing a List field annotated with @RestForm; and set the correct configuration key upon generating a native build from Gradle. More details on this release may be found in the changelog.

Open Liberty

IBM has released version 24.0.0.5 of Open Liberty featuring resolutions to the following Common Vulnerabilities and Exposures (CVEs) where a remote attacker can send a specially crafted request causing the server to consume memory resources resulting in a denial-of-service

• CVE-2024-27268, a vulnerability in WebSphere Application Server Liberty versions 18.0.0.2 through 24.0.0.4.
• CVE-2024-22353, a vulnerability in WebSphere Application Server Liberty versions 17.0.0.3 through 24.0.0.4.
• CVE-2024-25026, a vulnerability in WebSphere Application Server versions 8.5 and 9.0, and IBM WebSphere Application Server Liberty 17.0.0.3 through 24.0.0.4.

Notable bug fixes include: a ClassCastException upon using SIP Servlet 1.1 and WebSocket features; the featureUtility connection test to a base URL of a custom repository returns a HTTP 400 response code and fails to recognize it as a working repository. Further details on all of the bug fixes may be found in this list of issues.

Microsoft

After more than a year in development, Microsoft has introduced the general availability of Semantic Kernel for Java, an SDK that meshes Large Language Models (LLMs) with popular programming languages. Version 1.0 delivers: tool calling that enables an AI service to request the invocation of native Java functions; support for both text-to-audio and audio-to-text conversions with their audio service; an enhanced type conversion that allows user to register types and serialize/deserialize them to and from prompts; and the introduction of hooks to monitor key points such as function calls, enabling users to log or intercept them for better tracking and debugging. InfoQ will follow up with a more detailed news story.

Infinispan

Infinispan 15.0.4, the fourth maintenance release, provides notable changes such as: a resolution to a flaky test found in the TracingSecurityTest class; the addition of node names in the tracing spans; and a simplification of the default server configuration files. More details on this release may be found in the release notes and in this InfoQ news story on the release of Infinispan 15.0.0.

JHipster Lite

The release of JHipster Lite 1.9.0 ships with bug fixes, dependency upgrades and new features/enhancements such as: the addition of the Gradle frontend server plugin; removal of the gradleapp property from generate.sh as Gradle is now fully supported; and a simplification of lint-staged configuration. Further details on this release may be found in the release notes.

Langchain4j

Version 0.31.0 of LangChain for Java (LangChain4j) features new integrations: embedding models, Cohere and Jina; web search engines, Google and Tavily; the Jina scoring (re-ranking) model; and the Azure Cosmos DB for NoSQL embedding store. Breaking changes include: a rename of the Judge0 package from dev.langchain4j.code to dev.langchain4j.code.judge0; and a migration of the Anthropic language model from Gson to Jackson. More details on this release may be found in the release notes.

Article originally posted on InfoQ. Visit InfoQ

This week’s Java roundup for May 20th, 2024 features news highlighting: Java’s 29th birthday; the release of Kotlin 2.0 and Semantic Kernel for Java 1.0; JEP 477, Implicitly Declared Classes and Instance Main Methods (Third Preview), targeted for JDK 23; and four JEPs proposed to target for JDK 23

Java Turns 29

On May 23rd, 1995, Java 1.0 was introduced to developers who attended the Sun World ‘95 conference. A Java community was born and 29 years later, the community has evolved to include 370 global Java User Groups, 370 Java Champions and many Java-related conferences in a given calendar year. There have been 22 formal releases

At Devnexus 2024, Sharat Chander, Senior Director, Product Management & Developer Engagement at Oracle, announced that JavaOne will return to celebrate Java’s 30th birthday. It will be held March 17-20, 2025 in Redwood Shores, California. Please stay tuned for the call for papers.

OpenJDK

After its review has concluded, JEP 477, Implicitly Declared Classes and Instance Main Methods (Third Preview), has been promoted from Proposed to Target to Targeted for JDK 23. Formerly known as Unnamed Classes and Instance Main Methods (Preview), Flexible Main Methods and Anonymous Main Classes (Preview) and Implicit Classes and Enhanced Main Methods (Preview), this JEP incorporates enhancements in response to feedback from the two previous rounds of preview, namely JEP 463, Implicit Classes and Instance Main Methods (Second Preview), delivered in JDK 22, and JEP 445, Unnamed Classes and Instance Main Methods (Preview), delivered in JDK 21. This JEP proposes to “evolve the Java language so that students can write their first programs without needing to understand language features designed for large programs.” This JEP moves forward the September 2022 blog post, Paving the on-ramp, by Brian Goetz, Java Language Architect at Oracle. The latest draft of the specification document by Gavin Bierman, Consulting Member of Technical Staff at Oracle, is open for review by the Java community. More details on JEP 445 may be found in this InfoQ news story.

JEP 482, Flexible Constructor Bodies (Second Preview), has been promoted from Candidate to Proposed to Target for JDK 23. This JEP proposes a second round of preview and a name change to obtain feedback from the previous round of preview, namely JEP 447, Statements before super(…) (Preview), delivered in JDK 22. This feature allows statements that do not reference an instance being created to appear before the this() or super() calls in a constructor; and preserve existing safety and initialization guarantees for constructors. Changes in this JEP include: a treatment of local classes; and a relaxation of the restriction that fields can not be accessed before an explicit constructor invocation to a requirement that fields can not be read before an explicit constructor invocation. Gavin Bierman, Consulting Member of Technical Staff at Oracle, has provided an initial specification of this JEP for the Java community to review and provide feedback. The review is expected to conclude on May 27, 2024.

JEP 481, Scoped Values (Third Preview), has been promoted from Candidate to Proposed to Target for JDK 23. Formerly known as Extent-Local Variables (Incubator), this JEP proposes a third preview, with one change, in order to gain additional experience and feedback from one round of incubation and two rounds of preview, namely: JEP 464, Scoped Values (Second Preview), delivered in JDK 22; JEP 446, Scoped Values (Preview), delivered in JDK 21; and JEP 429, Scoped Values (Incubator), delivered in JDK 20. This feature enables sharing of immutable data within and across threads. This is preferred to thread-local variables, especially when using large numbers of virtual threads. The change in this feature is related to the operation parameter of the callWhere() method, defined in the ScopedValue class, is now a functional interface which allows the Java compiler to infer whether a checked exception might be thrown. With this change, the getWhere() method is no longer needed and has been removed. The review is expected to conclude on May 29, 2024

JEP 480, Structured Concurrency (Third Preview), has been promoted from Candidate to Proposed to Target for JDK 23. This JEP proposes a third preview, without change, in order to gain more feedback from the previous two rounds of preview, namely: JEP 462, Structured Concurrency (Second Preview), delivered in JDK 22; and JEP 453, Structured Concurrency (Preview), delivered in JDK 21. This feature simplifies concurrent programming by introducing structured concurrency to “treat groups of related tasks running in different threads as a single unit of work, thereby streamlining error handling and cancellation, improving reliability, and enhancing observability.” The review is expected to conclude on May 27, 2024.

JEP 471, Deprecate the Memory-Access Methods in sun.misc.Unsafe for Removal, has been promoted from Candidate to Proposed to Target for JDK 23. This JEP proposes to deprecate the memory access methods in the Unsafe class for removal in a future release. These unsupported methods have been superseded by standard APIs, namely; JEP 193, Variable Handles, delivered in JDK 9; and JEP 454, Foreign Function & Memory API, delivered in JDK 22. The review is expected to conclude on May 27, 2024.

JDK 23

Build 24 of the JDK 23 early-access builds was made available this past week featuring updates from Build 23 that include fixes for various issues. Further details on this release may be found in the release notes.

Jakarta EE 11

In his weekly Hashtag Jakarta EE blog, Ivar Grimstad, Jakarta EE Developer Advocate at the Eclipse Foundation, has provided an update on the upcoming GA release of Jakarta EE 11. Nine (9) specifications, namely – Jakarta Annotations 3.0, Jakarta Authorization 3.0, Jakarta Contexts and Dependency Injection 4.1, Jakarta Expression Language 6.0, Jakarta Interceptors 2.2, Jakarta RESTful Web Services 4.0, Jakarta Persistence 3.2, Jakarta Validation 3.1 and Jakarta WebSocket 2.2 – have been finalized for Jakarta EE 11. The remaining seven (7) updated specifications are in various stages of review.

Spring Framework

It was a busy week over at Spring as the various teams have delivered numerous milestone and point releases on Spring Boot, Spring Framework, Spring Cloud Data Flow, Spring Security, Spring Authorization Server, Spring for GraphQL, Spring Session, Spring Integration, Spring Modulith, Spring Batch, Spring AMQP, Spring for Apache Kafka and Spring for Apache Pulsar. More details may be found in this InfoQ news story.

Kotlin

JetBrains has released version 2.0 of Kotlin that finalizes the new frontend for the Kotlin compiler, codenamed K2, to unify all supported Kotlin platforms by which all compiler backends now share a significant amount of logic and a unified pipeline. Kotlin 2.0 promises faster compilation speed and support for Compose Multiplatform projects. JetBrains has also been developing a K2 Kotlin Mode, currently in alpha, for IntelliJ IDEA. Further details on this release may be found in the what’s new page. InfoQ will follow up with a more detailed news story.

Quarkus

Quarkus 3.10.2, the second maintenance release, ships with notable changes such as: a resolution to a QuarkusErrorHandler runtime error upon invoking a REST client endpoint that accepts a @BeanParam on a bean containing a List field annotated with @RestForm; and set the correct configuration key upon generating a native build from Gradle. More details on this release may be found in the changelog.

Open Liberty

IBM has released version 24.0.0.5 of Open Liberty featuring resolutions to the following Common Vulnerabilities and Exposures (CVEs) where a remote attacker can send a specially crafted request causing the server to consume memory resources resulting in a denial-of-service

• CVE-2024-27268, a vulnerability in WebSphere Application Server Liberty versions 18.0.0.2 through 24.0.0.4.
• CVE-2024-22353, a vulnerability in WebSphere Application Server Liberty versions 17.0.0.3 through 24.0.0.4.
• CVE-2024-25026, a vulnerability in WebSphere Application Server versions 8.5 and 9.0, and IBM WebSphere Application Server Liberty 17.0.0.3 through 24.0.0.4.

Notable bug fixes include: a ClassCastException upon using SIP Servlet 1.1 and WebSocket features; the featureUtility connection test to a base URL of a custom repository returns a HTTP 400 response code and fails to recognize it as a working repository. Further details on all of the bug fixes may be found in this list of issues.

Microsoft

After more than a year in development, Microsoft has introduced the general availability of Semantic Kernel for Java, an SDK that meshes Large Language Models (LLMs) with popular programming languages. Version 1.0 delivers: tool calling that enables an AI service to request the invocation of native Java functions; support for both text-to-audio and audio-to-text conversions with their audio service; an enhanced type conversion that allows user to register types and serialize/deserialize them to and from prompts; and the introduction of hooks to monitor key points such as function calls, enabling users to log or intercept them for better tracking and debugging. InfoQ will follow up with a more detailed news story.

Infinispan

Infinispan 15.0.4, the fourth maintenance release, provides notable changes such as: a resolution to a flaky test found in the TracingSecurityTest class; the addition of node names in the tracing spans; and a simplification of the default server configuration files. More details on this release may be found in the release notes and in this InfoQ news story on the release of Infinispan 15.0.0.

JHipster Lite

The release of JHipster Lite 1.9.0 ships with bug fixes, dependency upgrades and new features/enhancements such as: the addition of the Gradle frontend server plugin; removal of the gradleapp property from generate.sh as Gradle is now fully supported; and a simplification of lint-staged configuration. Further details on this release may be found in the release notes.

Langchain4j

Version 0.31.0 of LangChain for Java (LangChain4j) features new integrations: embedding models, Cohere and Jina; web search engines, Google and Tavily; the Jina scoring (re-ranking) model; and the Azure Cosmos DB for NoSQL embedding store. Breaking changes include: a rename of the Judge0 package from dev.langchain4j.code to dev.langchain4j.code.judge0; and a migration of the Anthropic language model from Gson to Jackson. More details on this release may be found in the release notes.

Article originally posted on InfoQ. Visit InfoQ

JEP 477, Implicitly Declared Classes and Instance Main Methods (Third Preview), has been promoted from its Proposed to Target to Targeted status. This JEP proposes to “evolve the Java language so that students can write their first programs without needing to understand language features designed for large programs.” This JEP moves forward the September 2022 blog post, Paving the on-ramp, by Brian Goetz, the Java language architect at Oracle. The latest draft of the specification document by Gavin Bierman, a consulting member of the technical staff at Oracle, is open for review by the Java community.

Java has long been recognized for its capabilities in building large, complex applications. However, its extensive features can be daunting for beginners who are just starting to learn programming. To address this, this JEP has introduced new preview features to simplify the language for new programmers. These features allow beginners to write their first programs without needing to understand complex language constructs designed for larger applications and empower experienced developers to write small programs more succinctly, enhancing their productivity and code readability.

Consider the classic Hello, World! example that is often a beginner’s first program:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

With this JEP, the above program can be simplified to:

void main() {
    println("Hello, World!");
}

The proposal introduces several key features designed to simplify Java for beginners while maintaining its robust capabilities. One of the main highlights is the introduction of implicitly declared classes, allowing new programs to be written without explicit class declarations. In this new approach, all methods and fields in a source file are considered part of an implicitly declared class, which extends Object, does not implement interfaces, and cannot be referenced by name in source code. Additionally, the proposal introduces instance main methods, which no longer need to be static or public, and methods without parameters are also recognized as valid program entry points.

With these changes, developers can now write Hello, World! As:

void main() {
    System.out.println("Hello, World!");
}

Top-level members are interpreted as members of the implicit class, so we can also write the program as:

String greeting() { 
    return "Hello, World!"; 
}

void main() {
    System.out.println(greeting());
}

Or, using a field as: 

String greeting = "Hello, World!";

void main() {
    System.out.println(greeting);
}

Following the initial preview in JDK 21 (JEP 445) and subsequent updates in JDK 22 (JEP 463), the proposal has been refined further based on community feedback. For instance, in this JEP, implicitly declared classes now automatically import the following three static methods from the new java.io.IO class for simple textual I/O:

public static void println(Object obj);
public static void print(Object obj);
public static String readln(String prompt);

This change eliminates the need for the System.out.println incantation, thereby simplifying console output. Consider the following example:

void main() {
    String name = readln("Please enter your name: ");
    print("Pleased to meet you, ");
    println(name);
}

Many other classes declared in the Java API are useful in small programs. They can be imported explicitly at the start of the source file:

import java.util.List;

void main() {
    var authors = List.of("James", "Bill", "Bazlur", "Mike", "Dan", "Gavin");
    for (var name : authors) {
        println(name + ": " + name.length());
    }
}

However, with the JEP 476, Module Import Declarations, implicitly declared classes automatically import all public top-level classes and interfaces from the java.base module, removing the need for explicit import statements for commonly used APIs such as java.util.List. This makes the development process more seamless and reduces the learning curve for new programmers. More details on JEP 476 may be found in this InfoQ news story.

This is a preview language feature, available through the --enable-preview flag with the JDK 23 compiler and runtime. To try the examples above in JDK 23, you must enable the preview features:

• Compile the program with javac --release 23 --enable-preview Main.java and run it with java --enable-preview Main; or,
• When using the source code launcher, run the program with java --enable-preview Main.java; or,
• When using jshell, start it with jshell --enable-preview.

Rather than introducing a separate dialect of Java, this JEP streamlines the declaration process for single-class programs. This approach facilitates a gradual learning curve, allowing beginners to start with simple, concise code and progressively adopt more advanced features as they gain experience. By simplifying syntax and minimizing boilerplate code, Java continues to uphold its reputation as a versatile and powerful programming language suitable for a wide range of applications. This enhancement not only makes Java more accessible to new programmers but also boosts productivity and readability for experienced developers working on smaller projects.

Article originally posted on InfoQ. Visit InfoQ

JEP 477, Implicitly Declared Classes and Instance Main Methods (Third Preview), has been promoted from its Proposed to Target to Targeted status. This JEP proposes to “evolve the Java language so that students can write their first programs without needing to understand language features designed for large programs.” This JEP moves forward the September 2022 blog post, Paving the on-ramp, by Brian Goetz, the Java language architect at Oracle. The latest draft of the specification document by Gavin Bierman, a consulting member of the technical staff at Oracle, is open for review by the Java community.

Java has long been recognized for its capabilities in building large, complex applications. However, its extensive features can be daunting for beginners who are just starting to learn programming. To address this, this JEP has introduced new preview features to simplify the language for new programmers. These features allow beginners to write their first programs without needing to understand complex language constructs designed for larger applications and empower experienced developers to write small programs more succinctly, enhancing their productivity and code readability.

Consider the classic Hello, World! example that is often a beginner’s first program:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

With this JEP, the above program can be simplified to:

void main() {
    println("Hello, World!");
}

The proposal introduces several key features designed to simplify Java for beginners while maintaining its robust capabilities. One of the main highlights is the introduction of implicitly declared classes, allowing new programs to be written without explicit class declarations. In this new approach, all methods and fields in a source file are considered part of an implicitly declared class, which extends Object, does not implement interfaces, and cannot be referenced by name in source code. Additionally, the proposal introduces instance main methods, which no longer need to be static or public, and methods without parameters are also recognized as valid program entry points.

With these changes, developers can now write Hello, World! As:

void main() {
    System.out.println("Hello, World!");
}

Top-level members are interpreted as members of the implicit class, so we can also write the program as:

String greeting() { 
    return "Hello, World!"; 
}

void main() {
    System.out.println(greeting());
}

Or, using a field as: 

String greeting = "Hello, World!";

void main() {
    System.out.println(greeting);
}

Following the initial preview in JDK 21 (JEP 445) and subsequent updates in JDK 22 (JEP 463), the proposal has been refined further based on community feedback. For instance, in this JEP, implicitly declared classes now automatically import the following three static methods from the new java.io.IO class for simple textual I/O:

public static void println(Object obj);
public static void print(Object obj);
public static String readln(String prompt);

This change eliminates the need for the System.out.println incantation, thereby simplifying console output. Consider the following example:

void main() {
    String name = readln("Please enter your name: ");
    print("Pleased to meet you, ");
    println(name);
}

Many other classes declared in the Java API are useful in small programs. They can be imported explicitly at the start of the source file:

import java.util.List;

void main() {
    var authors = List.of("James", "Bill", "Bazlur", "Mike", "Dan", "Gavin");
    for (var name : authors) {
        println(name + ": " + name.length());
    }
}

However, with the JEP 476, Module Import Declarations, implicitly declared classes automatically import all public top-level classes and interfaces from the java.base module, removing the need for explicit import statements for commonly used APIs such as java.util.List. This makes the development process more seamless and reduces the learning curve for new programmers. More details on JEP 476 may be found in this InfoQ news story.

This is a preview language feature, available through the --enable-preview flag with the JDK 23 compiler and runtime. To try the examples above in JDK 23, you must enable the preview features:

• Compile the program with javac --release 23 --enable-preview Main.java and run it with java --enable-preview Main; or,
• When using the source code launcher, run the program with java --enable-preview Main.java; or,
• When using jshell, start it with jshell --enable-preview.

Rather than introducing a separate dialect of Java, this JEP streamlines the declaration process for single-class programs. This approach facilitates a gradual learning curve, allowing beginners to start with simple, concise code and progressively adopt more advanced features as they gain experience. By simplifying syntax and minimizing boilerplate code, Java continues to uphold its reputation as a versatile and powerful programming language suitable for a wide range of applications. This enhancement not only makes Java more accessible to new programmers but also boosts productivity and readability for experienced developers working on smaller projects.

Article originally posted on InfoQ. Visit InfoQ

Subscribe on:

Apple Podcasts
Google Podcasts
Soundcloud
Spotify
Overcast
Podcast Feed

.
From this page you also have access to our recorded show notes. They all have clickable links that will take you directly to that part of the audio.

Article originally posted on InfoQ. Visit InfoQ

Subscribe on:

Apple Podcasts
Google Podcasts
Soundcloud
Spotify
Overcast
Podcast Feed

.
From this page you also have access to our recorded show notes. They all have clickable links that will take you directly to that part of the audio.