Performance

Faster Maven Builds (Part 2): Inside Docker

Following on from different techniques to fasten your Maven builds, I’d like to widen the scope and do the same for Maven builds inside Docker.

Faster Maven Builds (Part 1)

I want to detail some techniques you can leverage to make your Maven builds faster in this article. The next article will focus on how to do the same inside of Docker.

The Costs of Hidden Logging

The story of a partially implemented logging facility in the JDK 8 backport of JFR (for which I was also partially responsible)!

JDK Mission Control 8.1.0 Released!

Yay, the latest release of JDK Mission Control was just released!

Since this is the source release, it may still take a bit of time until the downstream vendors release binary builds of JDK Mission Control 8.1.0.

Optimizing Relational Database Access

PostgreSQL’s protocol is currently at version 3, and there are concerns about improving the protocol in this regard.

The V4 wire protocol changes and the wanted features for V4 documents share concerns about version 4 with pipelining and multiplexing in mind. PostgreSQL also has a proposed feature called Protocol hooks that decouples PostgreSQL from the current protocol. It aims to provide extensibility of the wire protocol. Such a feature could be an enabler for multiplexing.

It took 25 years to deliver HTTP/2 and introduce multiplexing to increase performance drastically. Most database protocols have not followed the same path yet and remain in the stone age of connection pooling (at least databases with an openly documented protocol).

Multiplexed database protocols could improve performance, and make connection pools a thing of the past. It would also provide the foundation for efficient data streaming from databases.

BlockHound: How It Works

BlockHound will transparently instrument the JVM classes and intercept blocking calls (e.g., IO) if they are performed from threads marked as “non-blocking operations only” (ie. threads implementing Reactor’s NonBlocking marker interface, like those started by Schedulers.parallel()).

If and when this happens (but remember, this should never happen!), an error will be thrown.

Apache Cassandra 4.0: Taming Tail Latencies with Java 16 ZGC

With Apache Cassandra 4.0, you not only get the direct improvements to performance added by the Apache Cassandra committers, you also unlock the ability to take advantage of seven years of improvements in the JVM itself.

This article focuses on improvements in Java garbage collection that Cassandra 4.0 coupled with Java 16 offers over Cassandra 3.11 on Java 8.

Concurrency in Java (and How it Compares with Other Modern Programming Languages)

This is a multi-part series where I talk about concurrency in modern programming languages and build and benchmark a concurrent web server, inspired by the example from the Rust book, in popular languages like Java, Rust, Go, JavaScript (NodeJS), TypeScript (Deno) and Kotlin to compare concurrency and its performance between these languages/platforms.

Part 6 is here on Foojay.io, the place for friends of OpenJDK.

Querying Your In-Memory-Data-Grid: Why and How?

In this post, we went through several core concepts covering querying your data on Hazelcast.

It makes sense to query your in-memory data because data access is fast.

By default, Hazelcast offers the Criteria API; you can use SQL as an alternative.

Use indexes judiciously to speed up your queries.

A (Definitive?) Guide to LazyInitializationException

Posts that have been written about Hibernate’s LazyInitializationException could probably fill whole books.

Yet, I believe each of them focuses on a particular aspect of it: some on a specific solution, some on how to solve it with Spring Boot, etc.

I’d like this post to be the definitive guide on the subject, even though I’m pretty sure it won’t.

At least, I’ll be able to point others to it!

Billion Events Per Second with Millisecond Latency: Streaming Analytics at Giga-Scale

We’re preparing a scientific paper on Hazelcast Jet, describing its architecture based on symmetric, data-local, non-blocking distributed event processing. As a part of this effort, we implemented the vendor-neutral NEXMark benchmark suite, consisting of 8 streaming queries that aim to capture typical kinds of questions you’re likely to ask about your real-time data.

The queries deal with a domain model of auctions, sellers, and bids. For example, Query 5 asks: “Which auctions have achieved the highest price in the last period?”