Performance

Community manager Kevin Farnham

Technology writer and software engineer focused on high-performance low-latency big-data Java, Python, C/C++ programming.

  • 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.

    Read more
  • 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.

    Read more
  • 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.

    Read more
  • 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.

    Read more
  • 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.

    Read more
  • Deep Dive Into Multi-Threading in Java

    Multi-threading represents a very intriguing topic, even after years of research and development for high quality, robust, and efficient software. With equal emphasis on hardware improvements and the software that runs on it – we have newer paradigms for parallelism.

    The most important yet basic concepts are the ones which I present here. I then explain the intricacies of multi-threading in the Java programming language. Some of these are newer features and supported only from the Java Platform Standard Edition 5.0. Let us start with a quick overview and understanding of the core concepts.

    Read more
  • 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!

    Read more
  • 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?”

    Read more
  • Kicking Spring Native’s Tires

    I’ve been playing with GraalVM Ahead-Of-Time compilation capability since I became aware of it.

    As a long-time Spring aficionado, I carefully monitored the efforts that the engineers at Tanzu have put into making Spring AOT-compatible. Recently, they announced the beta version of the integration.

    In this post, I want to check how easy it is to produce a (working!) Docker image from an existing Spring Boot application.

    Read more
  • Evolution of Java Memory Architecture (Post Java 7.0)

    Welcome to the next part of a series of articles on key concepts in Core Java and J2EE. The series revolves around memory architecture, connection and memory leaks, core Java syntax and semantics, Java Object layout/anatomy, multi-threading, asynchronous task execution, design patterns, Java agents, class loading, API design, OOPs & SOLID.

    Today, we learn about the evolution of the Java Memory Architecture, post Java 7.0.

    Read more
  • Evolution of Java Memory Architecture (Pre Java 8.0)

    Welcome to a series of articles on key concepts in Core Java and J2EE. The series revolves around memory architecture, connection and memory leaks, core Java syntax and semantics, Java Object layout/anatomy, multi-threading, asynchronous task execution, design patterns, Java agents, class loading, API design, OOPs & SOLID.

    In this part, we focus on the Java Memory Architecture, from before Java 8.

    Read more

Subscribe to foojay updates:

https://foojay.io/feed/
Copied to the clipboard