JDK 19 GA, JDK 20 EAb16, and some heads-up!

[David Delabassee <da...@oracle.com>]

Greetings!

JDK 19 has been released (General Availability) on September 2Oth as 
planned, the release cadence is working like clockwork! You can find the 
"The Arrival of Java 19" announcement here [1], and some additional Java 
19 material in the "Topics of Interest" section below. On behalf of the 
entire Java team, let me send our thanks to all of you. Through your 
active participation in this program, you are helping shape the Java 
platform!

With JDK 19 released, the focus should now shift to JDK 20 testing. As 
always, if you face any issues with early-access builds of JDK 20 please 
let us know. And do keep in mind that our GitHub Action [2] supports 
Early-Access builds, including JDK 20 EA.

With Virtual Threads (preview), Structured Concurrency (Incubutor), 
Record Patterns (Preview), the Foreign Function & Memory API (Preview), 
etc. Java 19 is a rich feature release, to say the least! This release 
also paves the way for an exciting future! To conclude with Java 19, all 
its features will be covered in great detail during JavaOne (Oct 17-20 
Las Vegas) [3]. If you are planning to come and haven't registered yet, 
I suggest to ping me ASAP.

[1] https://inside.java/2022/09/20/the-arrival-of-java-19/
[2] https://github.com/oracle-actions/setup-java
[3] https://inside.java/javaone/


## Heads-Up: JDK 19 - Double.toString() and Float.toString() change

A bug affecting Double.toString(double) and Float.toString(float) has 
been fixed in Java 19 [4]. According to the Javadoc, 
Double.toString(double) should produce a string with a number of digits 
as small as possible, that still uniquely distinguishes this double from 
its adjacent double. That was not the case for many doubles. For 
example, whereas 1e23 and 9.999999999999999E22 are the same double, 
passing 1e23 to Double.toString(double) was returning 
“9.999999999999999E22”. The specification has been updated, and the 
implementation along with it. As a consequence and starting with JDK 19 
some of the strings produced are now shorter than the ones produced in 
earlier releases. For example, passing 1e23 to this method in JDK 19 
will return “1.0E23" instead of “9.999999999999999E22” in earlier JDK 
releases. Note that in JDK 19, passing 9.999999999999999E22 to this 
method also returns "1.0E23" because they are the same double. Many 
string representations of doubles and floats have changed to match the 
specification update.

You can read the release notes [5] and some additional details here [4]. 
You can also learn more about floating point arithmetic in Joe Darcy's 
excellent "Floating-Point Arithmetic : What Every Java Programmer Should 
Know!" session [6].

[4] https://bugs.openjdk.org/browse/JDK-4511638
[5] https://bugs.openjdk.org/browse/JDK-8291475
[6] https://youtu.be/ajaHQ9S4uTA


## Heads-Up: JDK 20 - Drop support for -source/-target/--release 7 from 
javac

JEP 182 (Policy for Retiring javac -source and -target Options) 
describes a policy to remove at a regular pace, from the javac compiler, 
support for obsolete versions. This is required to reduce compiler 
maintenance costs. JEP 182 still needs to be updated to reflect the 
6-month release cadence but in that spirit and given that JDK 7 was 
released in July 2011, i.e. over a decade ago, support for 
-source/-target/--release 7 is dropped in JDK 20. All other supported 
values remain as such in JDK 20, 8 through 20 inclusive.

For more information, you might want to check JDK-8173605 [7] and JEP 
182: Policy for Retiring javac -source and -target Options [8].

[7] https://bugs.openjdk.org/browse/JDK-8173605
[8] https://openjdk.org/jeps/182


## General Availability of Java 19 / JDK 19

JDK 19 is now Generally Available [9]. The OpenJDK builds, provided 
under the GNU General Public License v2 with the Classpath Exception, 
are available here [10]. The JDK 19 Release Notes are available here [11].

[9] https://mail.openjdk.org/pipermail/jdk-dev/2022-September/006933.html
[10] https://jdk.java.net/19/
[11] https://jdk.java.net/19/release-notes

JDK 19 includes seven JEPs:
- JEP 405: Record Patterns (Preview)
- JEP 422: Linux/RISC-V Port
- JEP 424: Foreign Function & Memory API (Preview)
- JEP 425: Virtual Threads (Preview)
- JEP 426: Vector API (Fourth Incubator)
- JEP 427: Pattern Matching for switch (Third Preview)
- JEP 428: Structured Concurrency (Incubator)
along with hundreds of smaller enhancements and over a thousand bug fixes.


## JDK 20 Early-Access builds

JDK 20 Early-Access builds 16 are now available [12], and are provided 
under the GNU General Public License v2, with the Classpath Exception. 
The Release Notes are available here [13].

[12] https://jdk.java.net/20/
[13] https://jdk.java.net/20/release-notes

### Changes in 20EA-b16 that may be of interest:

- JDK-8293499: Provide jmod --compress option
- JDK-8290367: Update default value and extend the scope of 
com.sun.jndi.ldap.object.trustSerialData system property
- JDK-8244681: Add a warning for possibly lossy conversion in compound 
assignments
- JDK-8256265: G1: Improve parallelism in regions that failed evacuation
- JDK-8293861: G1: Disable preventive GCs by default
- JDK-8293922: Extend barrier-less Java thread transitions to native 
transition
- JDK-8290169: adlc: Improve child constraints for vector unary operations

### Additional changes that may be of interest:
- JDK-8288933: Improve the implementation of Double/Float.isInfinite
- JDK-8173605: Remove support for source and target 1.7 option in javac
- JDK-8288966: Better handle very spiky promotion in G1
- JDK-8291753: Add JFR event for GC CPU Time
- JDK-8292579: (tz) Update Timezone Data to 2022c
- JDK-8282648: Weaken the InflaterInputStream specification in order to 
allow faster Zip implementations
- JDK-8291660: Grapheme support in BreakIterator
- JDK-8292240: CarrierThread.blocking not reset when spare not activated
- JDK-8287908: Use non-cloning reflection methods where acceptable
- JDK-8292628: x86: Improve handling of constants in trigonometric stubs
- JDK-8292878: x86: Make scratch register usage explicit in assembler code
- JDK-8290249: Vectorize signum on AArch64
- JDK-8292203: AArch64: Represent Registers as values
- JDK-8292587: AArch64: Support SVE fabd instruction
- JDK-8292575: risc-v: Represent Registers as values

## Topics of Interest:

- Moving Java Forward with Java 19
https://inside.java/2022/09/20/moving-java-forward/

- “Java 19 is Here!” with Brian Goetz and Ron Pressler - Inside Java Podcast
https://inside.java/2022/09/20/podcast-026/

- JDK 19 - Security Enhancements
https://seanjmullan.org/blog/2022/09/22/jdk19

- JDK 19 - G1/Parallel/Serial GC improvements
https://tschatzl.github.io/2022/09/16/jdk19-g1-parallel-gc-changes.html

- “Java 19 in Action” - Inside Java Newscast
https://inside.java/2022/09/08/insidejava-newscast-033/

- G1 Pre-Barrier Implementation
https://albertnetymk.github.io/2022/07/22/g1_barrier/

- New candidate JEP: 430: String Templates (Preview)
https://openjdk.org/jeps/430

- OpenJDK: Where the Magic Happens
https://inside.java/2022/09/12/change-the-future-of-java/


That's it for this time. I hope to see some of you in a few weeks during 
JavaOne in Vegas. And again, if you haven't made your J1 plans yet, 
please ping me.

--David