The article introduces mvnd, a GraalVM‑based Maven daemon that accelerates builds by reusing processes, leveraging JIT compilation, and supporting parallel execution, then details installation across Linux, macOS and Windows, configuration tips, and usage commands, showing how it narrows the performance gap with Gradle.
This article introduces mvnd, a GraalVM‑based Maven daemon that runs as a persistent build service, explains how it achieves faster startup and parallel builds, and provides step‑by‑step installation, configuration, and usage instructions for Windows, macOS, and Linux.
This curated collection gathers essential articles and tutorials covering Java 8‑17 updates, GraalVM performance tricks, Spring Native adoption, Spring Cloud and RSocket alternatives, GraphQL frameworks, observability stacks like Grafana, Prometheus and Loki, IDE enhancements, database fundamentals, and low‑code platform building, providing a comprehensive knowledge base for modern backend developers.
This article walks through writing a simple Java program, compiling it with javac, then using GraalVM's native-image tool to produce a JVM‑independent executable, compares file size and startup speed, discusses native-image limitations, and shows how Spring Boot can be built as a native image for dramatically faster startup.
Spring Native Beta introduces Maven and Gradle plugins and native‑configuration annotations that let Spring applications be compiled into GraalVM native images, enabling ultra‑fast startup, low memory usage, and container‑friendly executables for cloud‑native deployments.
The article introduces mica-mqtt, an open‑source MQTT component built on t‑io that offers simple, low‑latency, high‑performance messaging, outlines its features, provides Spring Boot and plain Java integration steps, shows configuration examples, and explains monitoring and clustering capabilities for IoT applications.
The article introduces mica-mqtt, a lightweight, low‑latency, high‑performance MQTT component built on t‑io, detailing its features, configuration for Spring Boot and plain Java projects, custom interfaces, clustering, monitoring with Prometheus‑Grafana, and provides code examples for both server and client integration.
GraalVM 21.2 introduces major updates across its ecosystem, including new Gradle and Maven plugins for Native Image with JUnit 5 support, enhanced compiler optimizations, expanded Truffle language capabilities, improved JavaScript, Ruby, Python, LLVM, and upgraded tooling such as VisualVM and JFR integration.
This guide walks through building the mica-mqtt MQTT component with GraalVM native-image, covering dependency setup, Caffeine configuration, Maven plugin settings, binary compression with UPX, and performance comparisons that demonstrate millisecond‑level startup versus traditional JAR execution.
This tutorial demonstrates how to create a Micronaut microservice, compile it into a GraalVM Native Image, and apply advanced optimizations such as G1 GC, profile‑guided compilation, and UPX packing to achieve faster startup, lower memory usage, and higher throughput in cloud environments.
Spring Native beta introduces Maven and Gradle plugins that let Spring applications be compiled into GraalVM native images, delivering near‑instant startup, reduced memory usage, and container‑ready executables while outlining supported features, AOT transformation, and practical use cases for cloud‑native deployments.
Spring Native beta lets Spring applications run as GraalVM native images, offering near‑instant startup, reduced memory usage, and container‑ready executables, while providing Maven/Gradle plugins, AOT transformation, and broad Spring ecosystem support for modern cloud‑native deployments.
This article walks through building a Spring Native application with GraalVM, demonstrates how to generate native‑image configuration files, and shows step‑by‑step integration of Mica components such as ip2region, captcha, and caffeine using Spring Native hints and custom resource configurations.
Through a series of benchmark tests comparing simple, logging‑enabled microservices written in Java (Helidon) and Go (Go‑Kit), the authors evaluate whether Java can achieve Go‑like performance, exploring JVM tuning, GraalVM native images, and Kubernetes deployments to uncover speed, memory, and scalability trade‑offs.
This guide walks you through installing GraalVM, configuring Spring Native with Maven, building a native executable, and compressing it with UPX, demonstrating how to create high‑performance Java microservices in just a few minutes.
This guide introduces GraalVM’s key capabilities—including a high‑performance JIT compiler, native‑image generation for low‑memory binaries, and seamless polyglot support—while providing essential command‑line options and code examples for Java, native, and multiple language development.
This guide summarizes GraalVM's key capabilities—including a high‑performance JIT compiler, native‑image generation for instant startup and low memory, and polyglot support for multiple languages—while providing essential command‑line options and code examples for developers.
The Spring Native beta release lets developers compile Spring applications into GraalVM native images via start.spring.io, offering near‑instant startup, peak performance, and lower memory usage while outlining usage, collaboration, supported scope, AOT transformation, and future roadmap.
This article provides a concise, English‑language guide to GraalVM, covering its high‑performance JIT compiler, native‑image generation for instant‑start binaries, and polyglot capabilities for running Java, JVM languages, JavaScript, Python, Ruby, R, and more, with key commands and options.
This article examines whether Java microservices can be as fast as Go by presenting a series of benchmark tests using simple services, Helidon and Go toolkits, various JVMs, GraalVM native images, and Kubernetes deployments, and analyzing latency, throughput, and memory usage across multiple hardware configurations.
The article reviews Spring’s 2020 developments, highlighting its reintegration with VMware, massive SpringOne attendance, deep Kubernetes integration, new Spring Boot features, Reactive programming support, GraalVM native images, RSocket protocol, and the latest Java and Kotlin enhancements for cloud‑native applications.
This article explains how to install GraalVM and its native‑image component, configure a Spring Boot 2.4 project for native compilation, and compare startup time and memory usage between traditional JVM and GraalVM‑compiled executables, demonstrating significant performance gains.
This guide walks through installing GraalVM, adding the native‑image tool, creating a Spring Boot 2.4 project, configuring it for GraalVM, building a native executable, and comparing startup time and memory usage, showing how GraalVM can reduce startup from over a second to 0.2 seconds and memory from 480 MB to 25 MB.
This article presents a systematic performance comparison between Java and Go microservices—covering raw speed, memory usage, logging impact, GraalVM native images, and Kubernetes deployments—to reveal when each language excels and the practical trade‑offs involved.
This article evaluates popular Java microservice frameworks—Spring Boot, Micronaut, Quarkus, and Helidon MP—by measuring their ease of development, compilation time, startup latency, memory usage, and high‑load request handling, using identical CRUD applications deployed on Docker and GraalVM.
Oracle’s Jim Laskey proposes JEP 372 to drop the Nashorn JavaScript engine and its APIs from the JDK, detailing the modules to be removed, the impact on javax.script, and community reactions including a shift toward GraalVM.
GraalVM 19.3, Oracle's open‑source next‑generation virtual machine, enables developers to build high‑performance, multi‑language applications using Java, Python, Ruby, R, Scala, Kotlin, and even C/C++, with LTS support, modularity via JPMS, and fast startup, offering a compact, versatile runtime for modern development.
This article demonstrates how Java applications can be made smaller, faster to start, and more resource‑efficient in the cloud‑native era by using multi‑stage Docker builds, OpenJ9’s shared class cache and AOT compilation, and GraalVM native images, with step‑by‑step examples based on the Spring PetClinic and Micronaut projects.
This article explores why Java faces challenges in the cloud‑native era, demonstrates how multi‑stage Docker builds, OpenJ9 shared class cache, and Micronaut‑GraalVM native compilation can dramatically reduce image size and cut startup time by up to 50 % while also lowering memory consumption.
This article explains Java's traditional JIT compilers, introduces Graal as a modular Java‑level JIT and AOT compiler, compares its optimizations with HotSpot's C2, and provides practical steps to enable Graal in Java 10, offering deeper insight into JVM performance tuning.
