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 a bright 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