JEP 468 proposes a solution to the verbosity that can come from modeling mutable state with immutable records: derived record creation aka with expressions aka withers. | Continue reading
The ongoing introduction of pattern matching to Java has unbalanced the language. Here's how primitive patterns (in Java 23) and other patterns (in future versions) will fix that. | Continue reading
Pattern matching Optional, expanding sealed type hierarchies, nesting switches, reverting instanceof, and more - so many (dirty) tricks to play around with in modern Java | Continue reading
Java 22 brings multi source-file execution to the platform. It allows us to run programs consisting of multiple source files and even dependencies with just a simple java command. For experienced developers, this will make exploration and experimentation simpler but it's a real g … | Continue reading
With so much going on in the programming language space, it's easy to miss any specific language's success story and so in this talk I want to put a particularly hot one on your radar | Continue reading
Whether for validation, preparation, or splitting and sharing arguments, it can be quite annoying that Java doesn't allow statements before the super(...) or this(...) call in a constructor. Luckily Java 22 is about to change that with JEP 447, which previews statements before th … | Continue reading
In 2024, Java keeps evolving. Here's what the big OpenJDK projects (Amber, Leyden, Valhalla, and more) plan for this year and how that will push Java forward. | Continue reading
2023 is coming to a close and it was quite a year for Java! Let's look back at some of the highlights: on-ramp improvements, why Java 8 is dying, JVMLS, community achievements, and how cool our YouTube channel is. | Continue reading
Project Valhalla's value types need to be aware of which instance can be null and which can't, so the JVM can inline them. So will Java get a null-aware type system after all? Not quite, but it may get close and JSpecify can help with some of those steps. | Continue reading
Kevin Bourrillion gives an introductory presentation on JSpecify, a project spearheading a set of standard annotations for Java static analysis, specifically for tracking null | Continue reading
JDK 22 will be released on March 19th 2024 but it's forked today (Dec 7th 2023) and so its feature set is final. Unnamed patterns and variables, the FFM API, and multi-source-file programs are the highlights but there is so much more. Let's unpack! | Continue reading
Babylon is OpenJDK's newest big project, aimed at easing execution of Java code on the GPU, which will unlock machine learning and artificial intelligence on the JVM. Here's all about its background, prototypes, and plans. | Continue reading
Implementing a bunch of Gatherers to better understand the proposed addition to the stream API | Continue reading
Stream::gather is a new intermediate meta-operation that allows the JDK and us to implement all kinds of intermediate operations as Gatherers without overloading the Stream interface | Continue reading
Try/catch expressions? Valhalla timeline? Synchronizing virtual threads? And many more. Here's how Brian Goetz, Alan Bateman, Stuart Marks, and Kevin Rushforth answered your questions. | Continue reading
How the new class-file API that Brian Goetz presented at JVMLS will greatly improve the situation around Java updates | Continue reading
Java 21 is the first Java release with all essential pattern matching features finalized: sealed types, type patterns, an improved switch, records, and record patterns. This tutorial puts them all together. | Continue reading
Let's write a GitHub Crawler and let's throw in everything Java (21) has to offer | Continue reading
Java 21 is chock-full of great features but that's for naught of you can't actually upgrade, so I've collected all potential upgrade hurdles and we'll go over every issue that you may encounter on the road from Java 17 to 21 | Continue reading
Let's separate Java from JDK, OpenJDK from its vendors, and maintenance from support, so we better understand how the ecosystem functions and what long-term support really means. | Continue reading
Java 21 is an explosive release! From virtual threads to pattern matching, from better APIs, GC, and tooling to exciting previews - it's a blast. | Continue reading
OMG, how is there even more in JDK 21?! Scoped values preview, key encapsulation mechanism API, a new JFR command, and various API improvements. Generational Shenandoah is out, though, and it doesn't look good for the 32-bit Windows port either. | Continue reading
JDK 21 is almost too good to be true: It finalizes virtual threads, sequenced collections, generational ZGC, and the pattern matching basics; and evolves and introduces over half a dozen other features. | Continue reading
To give Java and programming beginners a better learning path, JEP 445 proposes to allow stand-alone main methods that are non-public, non-static, and don't have an args array and we're also JEP draft for multi-file programs | Continue reading
Virtual threads combine the simplicity of blocking code with the resource efficiency and scalability of reactive programming and in this talk you're going to learn how they do that and how you can use them in your project | Continue reading
JDK Enhancement Proposal 450 proposes to merge a compressed class word into the mark word to reduce object header size on 64-but systems from 96-128 bits to 64 bits, thus saving 10-20% of heap space | Continue reading
JEP 443 proposes to add unnamed variables and patterns to Java. With them, unused variables and patterns can be replaced by a single underscore, which helps writing readable and maintainable code. | Continue reading
All lists, some sets, and some maps have an encounter order, but the collections framework has no type to capture this property and define operations like getting or removing first and last elements or iterating in reverse order. Sequenced collections will fix that in Java 21. | Continue reading
The list of big new features that can be used in production with Java 20 is rather short: . (That was it already.) Pretty boring, these six-month releases. We really don't need to take a closer look ... | Continue reading
The goal of Project Leyden is to improve the startup time, time to peak performance, and footprint of Java programs. Project lead MArk Reinhold recently proposed to extend the Java programming model with features for selectively shifting and constraining computation with condenso … | Continue reading
What do the security manager, applet API, finalization, and primitive wrapper constructors have in common? What about CMS, Nashorn, RMI activation, and biased locking? And what does jdeprscan have to do with all of this? | Continue reading
A summary of what happened in 2022 and what will probably happen in 2023 for Projects Amber, Galahad & Leyden, Lilliput, Loom, Panama, and Valhalla | Continue reading
JDK 18 and JDK 19 preview a number of big ticket features but they also come with a lot of smaller improvements. Here are 24 less-known features that were added to Java in 2022. Among them additions to Future and ForkJoinPool, to HashSet and HashMap, Security and GC improvements, … | Continue reading
How does a community of Java enthusiasts drive innovation for 15 years, turning ideas into designs into code into features you can use in your IDE. | Continue reading
Oracle will contribute GraalVM's just-in-time compiler and native image technology to OpenJDK. It will also create EA and GA builds for JavaFX 20+ and is hard at work at creating generational ZGC to vastly improve ZGC's already impressive performance. And then there's the Java SE … | Continue reading
Visibility, classes, methods, instance and static members, parameters - a newcomer to programming needs to learn all of these concepts to truly understand a simple hello-world program in Java. Time to make that simpler and cut down on what needs to be known up front. | Continue reading
Project Amber steadily and carefully chips away at Java's persistent pain points. This talk discusses released, previewing, and upcoming features achieve that and make Java more expressive, more succinct, and more readable. | Continue reading
Data-oriented programming models data as data: records for entities and sealed types for alternatives. Combined with pattern matching we can define operations on the data without overloading it with functionality. | Continue reading
Among other things, Java 19 ships with virtual threads, structured concurrency APIs, sealed types, and pattern matching in switch - all of them as previews, but still very cool! I'm using these features here to create a GitHub crawler. | Continue reading
Among other things, Java 19 ships with virtual threads, structured concurrency APIs, sealed types, and pattern matching in switch - all of them as previews, but still very cool! I'm using these features here to create a GitHub crawler. | Continue reading
String templates make it easy and safe to embed variables and expressions in strings; JavaFX 19 comes with many improvements, chief among them derived observables; and the deserialization filter can keep apps safe from certain attacks. More on all of this at JavaOne! | Continue reading
Sequenced collections introduce an abstraction for collections with a known encounter order like all lists and some sets and maps. It will be easy to add, get, or remove the first and last elements and to iterate or stream in reverse order. We're also discussing immutable collect … | Continue reading
We asked you for questions on YouTube, Reddit, and Twitter and are here to answer a bunch of them. From projects Amber to Valhalla, Leyden to Lilliput, from language to performance, from the immediate future to pipe dreams we covered a lot of ground. | Continue reading
Data-oriented programming focuses on modeling data as data (instead of as objects). Records for data and sealed types for alternatives let us model immutable data where illegal states are unrepresentable. Combined with pattern matching we get a safe, powerful, and maintainable ap … | Continue reading
What's "OpenJDK" (or "the OpenJDK"?), how does it work, and what does it do? Here's the answer to these questions as well as explorations of JDK Enhancement Proposals, the Java Community Process, why there are so many JDK providers, and how long-term support works. | Continue reading
Java 19 is the first release to preview Project Loom's virtual threads and structured concurrency, Project Amber's record patterns, and Project Panama's foreign memory and function APIs. It also continues previews of pattern matching in switch and vector API. Put together, this m … | Continue reading
How record patterns use records' transparency to safely deconstruct them in pattern matching, allowing us to separate checking structure and value of data from processing it. | Continue reading
Project Loom's virtual threads are merged and ship with JDK 19 - here's to prepare for them. Also, news on Project Lilliput, proposal for record patterns in pattern matching, some astonishing numbers from Sonatype on Maven Central, and the move of OpenJDK to openjdk.org. | Continue reading