Java News

Future Java - Prepare Your Codebase Now! - Inside Java Newscast #41

By Nicolai Parlog on February 2, 2023

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?

Read More
Java Modules in Real Life

By Nicolai Parlog on January 29, 2023

Get advice on why, when, when not, and how to use Java modules in real life for your Java projects.

Read More
Quality Outreach Heads-up - JDK 21: JMX Subject Delegation & Fine-grained Security Deprecation

By David Delabassee on January 27, 2023

This Heads-Up is part of the regular communication sent to the projects involved, it covers some deprecation related to JMX.

Read More
JDK 21 - Performance Improvements Revealed

By Per-Ake Minborg on January 26, 2023

In Java 21, old code might run significantly faster due to recent internal performance optimizations made in the Java Core Libraries. In this article, we will take a closer look at some of these changes and see how much faster your favorite programming language has become. Buckle up, for we are about to run at full speed!

Read More
Tutorial - The Java I/O API

By Jose Paumard on January 26, 2023

Java I/O is a set of classes that give access to external resources including file systems and the network. This tutorial will guide you through the Java I/O API, presenting the basic notions you need to understand in order to start writing Java code that takes advantage of the API....

Read More
ZGC - The Future of Low-Latency Garbage Collection Is Here

By Erik Osterlund on January 25, 2023

The Z Garbage Collector (ZGC) is a scalable low-latency garbage collector providing sub-millisecond max pause times. Get an overview of the design principles behind ZGC, how it performs, and how to best use it to reduce latency for your application. We also look at the ongoing work to make ZGC a generational garbage collector.

Read More
On Markdown in (Java) documentation

By Jonathan Gibbons on January 24, 2023

As some folk have already noticed, we are investigating the possibility of supporting Markdown in Java documentation comments. Why are we doing this? It has been an informal request for a while now, since the emergence of Markdown as a popular authoring format, and so we're doing it for all the same reasons that authors prefer to use Markdown instead of raw HTML in standalone documentation. In particular, using raw HTML is somewhat clunky and visually intrusive, for simple formatting tasks, like font changes, lists, and tables, that are often desired in API documentation...

Read More
Lifetimes in the Foreign Function & Memory API

By Maurizio Cimadamore on January 23, 2023

The Foreign Function & Memory API (FFM in short) in centered around the idea of explicit lifetime management. That is, memory segments allocated using the FFM API are assigned a lifetime (known as SegmentScope), which determines when can the segments be accessed (e.g. when is their backing region of memory still available), and by whom (e.g. which threads can access the memory segment). In this document we show why existing approaches to explicit memory management such as malloc/free are not sufficient for the FFM API, and how reasoning about lifetimes helps programs using the FFM API avoid pesky temporal bugs (also known as use-after-free).

Read More
Java’s Plans for 2023 - Inside Java Newscast #40

By Nicolai Parlog on January 19, 2023

A summary of what happened in 2022 and what will probably happen in 2023 for Projects Amber (pattern matching, relaxed `main` and `super()` and much, much more), Galahad & Leyden (foundation and first steps), Lilliput (64bit object headers; on to 32bit), Loom (previewed virtual threads, incubated structured concurrency and scoped values; work on finalizing all that plus less pinning), Panama (vector API is stable and waits for Valhalla, foreign APIs are previewing; FFM API improvements and work towards finalization), and Valhalla (EA builds; revisions).

Read More
Java 20 - An Almost Infinite Memory Segment Allocator

By Per-Ake Minborg on January 18, 2023

Wouldn’t it be cool if you could allocate an infinite amount of memory? In this article, we will learn how memory-mapped files can be leveraged as an under-carriage for providing a memory-allocating arena that can return an almost infinite amount of native memory without ever throwing an OutOfMemoryError.

Read More


Sourced from https://inside.java via RSS.