After finishing the Spring Boot source‑code series, the author launches a refreshed Spring Cloud microservices tutorial built on Spring Boot 3.x, Jakarta EE, GraalVM native images, full production‑grade demos, Kubernetes deployment, observability and performance testing, outlining a 12‑episode roadmap.
AgentScope Java is an open‑source, agent‑oriented framework that brings ReAct, tool calling, memory, multi‑agent collaboration, runtime intervention, plug‑in integration, reactive architecture, GraalVM native images and OpenTelemetry observability to Java, enabling production‑grade AI agents with familiar Java tooling.
The OpenAI Java SDK has released three versions (4.29.0, 4.31.0, 4.32.0) within weeks, adding a Responses API, Spring Boot starter, webhook verification, request‑ID handling, automatic retries, and GraalVM compatibility, turning it from a simple HTTP wrapper into a production‑ready backend component for Java developers.
This article walks through converting a Spring Boot order‑query microservice to a GraalVM Native Image, detailing environment setup, common build pitfalls with concrete code fixes, Docker multi‑stage packaging, K8s scaling comparison, performance benchmarks, CI/CD integration, and guidance on when Native Image is appropriate.
The article explains how AI's need for efficient, machine‑readable interfaces is shifting software value from graphical UIs to command‑line and text‑based UIs, reviews recent CLI releases from major Chinese platforms, and presents Java solutions such as Picocli, TamboUI, and GraalVM native images for building robust, AI‑friendly tools.
This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.
A NetEase interview probes deep JVM garbage‑collection knowledge, exposing misconceptions about default GC, demanding precise G1/ZGC tuning, and challenging candidates with performance‑critical scenarios that reveal hidden latency and memory‑usage pitfalls.
This article walks through Spring 6’s core upgrades—including JDK 17 baseline, Project Loom virtual threads, @HttpExchange declarative clients, RFC 7807 ProblemDetail handling, GraalVM native‑image compilation, and Micrometer‑Prometheus monitoring—showing concrete code, performance numbers, migration steps, and real‑world e‑commerce use cases.
This article walks through the core upgrades in Spring 6 and Spring Boot 3—raising the JDK baseline, adopting Project Loom virtual threads, using the new @HttpExchange declarative client, standardizing error responses with ProblemDetail, compiling to GraalVM native images, and adding Prometheus monitoring—while providing concrete code examples, performance numbers, and a step‑by‑step migration roadmap.
This article walks through the One Billion Row Challenge—parsing a 13 GB file of 1 billion temperature records—by examining the baseline Java solution, analyzing top contestants' results, and detailing a step‑by‑step series of low‑level optimizations (JVM choice, parallel I/O, custom parsing, bespoke hash tables, Unsafe and SWAR techniques) that shrink execution time from minutes to under two seconds.
The author reviews common Java desktop packaging methods—GraalVM, JLink, Exe4J, batch scripts, and plain JAR—detailing their advantages and drawbacks, then demonstrates a custom WinForm‑based packaging utility that bundles a Swing application and a trimmed JRE into a single executable for double‑click launch.
This guide compares common Java desktop packaging methods, evaluates their pros and cons, and demonstrates a custom Winform tool that bundles a Swing program and a minimal JRE into a single executable for easy distribution.
Spring Boot 4.0 GA introduces a modern Java baseline, native virtual‑thread support, GraalVM native image integration, streamlined API versioning, a lightweight @HttpExchange client, enhanced security and observability features, and a list of breaking changes, with migration guidance for developers.
This article introduces Maven‑mvnd, a daemon‑based Maven wrapper that dramatically reduces build time and resource usage for Java projects, explains its key features, provides step‑by‑step installation and configuration instructions, and compares its packaging performance against standard Maven.
SpringBoot 3.0 drops the long‑standing spring.factories file in favor of per‑extension imports files, eliminating full‑classpath scans, improving startup speed, aligning with Java modules, and enabling seamless GraalVM native‑image support, while providing a clear migration path for existing projects.
Maven‑mvnd introduces a long‑running daemon, GraalVM native binaries, and seamless Maven compatibility to cut JVM startup overhead, lower CPU/memory use, and accelerate multi‑module builds, offering a low‑risk path to faster Java project compilation.
This article reviews seven popular Java micro‑frameworks, comparing their popularity, key advantages, and GitHub repositories, while highlighting performance benefits of GraalVM native images and the impact of Java 21 virtual threads for cloud‑native, lightweight web applications.
This comprehensive guide explains why reflection configuration is essential for GraalVM native compilation, details Spring Boot 3's reflection mechanisms, enumerates common pitfalls with concrete solutions, and presents best‑practice strategies and tooling to reliably build native images for Java back‑ends.
Spring Boot 4.0, currently in preview with a GA slated for November 2025, introduces modular architecture, API versioning, BeanRegistrar, JSpecify null‑safety, GraalVM native image support, virtual threads, and up to 800% performance gains, while outlining a detailed release timeline and migration considerations for developers.
This article reviews the major enhancements in Spring Boot 4 and Spring Framework 7, covering baseline requirements, performance boosts, native image support, modularization, new annotations, API versioning, declarative HTTP clients, resilient method support, multiple TaskDecorators, and null‑safety improvements, with practical code examples to help developers plan their migration.
Learn to compile a Spring Boot 3.5.6 application into a fast-starting native binary using GraalVM, configure the environment, add Maven plugins, write simple test code, and package the result into a lightweight Docker image, achieving dramatically reduced startup time and image size.
This article explores comprehensive strategies for dramatically reducing Spring Boot application startup latency, covering real‑world case studies, dependency slimming, JVM and CDS tuning, lazy and asynchronous bean initialization, GraalVM native image compilation, and advanced runtime techniques such as CRaC, with detailed metrics and step‑by‑step guidance.
This article explains the C10K problem and provides practical, non‑blocking and reactive strategies, thread‑count minimization, Netty configuration, memory management, and emerging technologies like GraalVM Native‑Image and Project Loom to keep Java servers stable under massive concurrent connections.
Spring Boot 4, built on Spring Framework 7, introduces elegant API versioning, streamlined Bean registration, null‑safety annotations, simplified HTTP proxy creation, upgraded SPEL, GraalVM native support, Jackson 3.x, newer Servlet/WebSocket versions, and numerous other enhancements, offering developers more powerful and convenient tools.
SpringBoot 3.0 removed the traditional spring.factories file to improve startup performance, modularity, and GraalVM native image support, and introduces a new imports‑based registration mechanism with detailed migration steps, code examples, and best‑practice guidance for developers.
This article provides a comprehensive overview of the Spring ecosystem upgrade, detailing Spring 6 core features such as JDK 17 baseline, Project Loom virtual threads, declarative HTTP clients, RFC‑7807 ProblemDetail handling, GraalVM native images, as well as Spring Boot 3 breakthroughs like Jakarta EE migration, OAuth2 server, Prometheus monitoring, and practical migration roadmaps for cloud‑native applications.
This guide compares five Java Swing packaging approaches, evaluates their pros and cons, and demonstrates a custom WinForm tool that bundles a Swing app with a minimal JRE into a standalone executable, complete with example Maven configuration and source code.
SpringBoot 3.0 removes the long‑standing spring.factories file due to performance, modularity, and GraalVM native image challenges, introduces a new imports‑file mechanism, and provides detailed migration steps, code examples, performance comparisons, and best practices for GraalVM integration.
This article explains how Java's Just‑In‑Time (JIT) compilation and tiered (layered) compilation work together to transform bytecode into native code, improve runtime performance, balance startup speed, and offers practical configuration tips for fine‑tuning JVM behavior.
This article compares five Java packaging methods—GraalVM, JLink, Exe4J, batch scripts, and plain JAR—detailing their pros and cons, then introduces a custom WinForm tool that bundles Swing applications into self‑contained executable files, complete with code examples and deployment steps.
This article explains the removal of the spring.factories file in Spring Boot 3, the performance and modularity reasons behind it, introduces the new imports‑based mechanism, provides step‑by‑step migration guidance, and shows how the change improves GraalVM native image support.
This article explains how Maven‑mvnd accelerates Java project builds by using a long‑living daemon to avoid repeated JVM startups, reduces resource consumption, improves CI/CD feedback loops, and offers easy migration from standard Maven with no syntax changes.
This article explains the major enhancements in Spring 6.0 and Spring Boot 3.0—including a JDK 17 baseline, Project Loom virtual threads, @HttpExchange declarative HTTP clients, RFC 7807 ProblemDetail error handling, GraalVM native image support, AOT compilation, OAuth2 server setup, and Micrometer‑Prometheus monitoring—while providing a practical upgrade roadmap and code samples.
Maven‑mvnd introduces a long‑running daemon, GraalVM native execution and seamless Maven compatibility to dramatically reduce build time, lower resource consumption, and improve feedback loops for large or multi‑module Java projects.
The article surveys the Spring 6 and Spring Boot 3.0 upgrades—JDK 17 baseline, virtual threads, @HttpExchange client, RFC 7807 ProblemDetail handling, GraalVM native images, Jakarta EE 9+ migration, enhanced auto‑configuration, OAuth2 authorization server, Prometheus‑compatible metrics—and provides a step‑by‑step migration roadmap with practical recommendations for modernizing e‑commerce applications.
This article provides a comprehensive guide to Spring 6.0’s new baseline JDK 17 requirement, virtual threads, declarative HTTP clients, RFC‑7807 ProblemDetail handling, GraalVM native image support, and Spring Boot 3.0 improvements such as Jakarta EE migration, OAuth2 authorization server, Prometheus monitoring, and practical migration steps for enterprise applications.
Oracle’s March 2025 release of JDK 24 and GraalVM 24 introduces a new Class‑File API and Premain support for Java agents, allowing static compilation of agents, improving observability, reducing native image size, and delivering measurable startup‑time and memory‑usage gains.
SpringBoot 3.0 eliminates the long‑standing spring.factories file due to startup performance penalties, lack of modular support, static configuration limits, and incompatibility with GraalVM native images, and replaces it with a set of imports files that provide clearer, faster, and more modular auto‑configuration registration.
Quarkus, a Kubernetes‑native Java framework built for GraalVM and HotSpot, delivers millisecond startup, low memory usage, developer‑friendly features, and seamless integration with cloud‑native platforms, making it ideal for microservices, serverless, and modern cloud applications.
This guide walks through the prerequisites, GraalVM installation, Maven setup, and step‑by‑step packaging of a Spring Boot 3 application into a native executable using AOT compilation, runtime hints, and Docker, demonstrating dramatically faster startup times.
This article explains how to prepare the environment, configure GraalVM, use Maven plugins, and apply Spring Boot 3.0 AOT and RuntimeHints to compile a Spring Boot application into a fast‑starting native executable, including Docker packaging and underlying AOT principles.
This article evaluates the startup speed, memory consumption, and request‑handling throughput of a Spring Boot application built as a GraalVM native binary, a regular JAR, and equivalent services written in Go and Rust, highlighting the trade‑offs of AOT compilation for backend development.
This article reviews several methods for distributing Java Swing applications as standalone executables—including GraalVM native images, JLink, Exe4J, batch scripts, and plain JAR distribution—compares their advantages and drawbacks, and demonstrates a custom WinForm packaging tool with example Maven and source code.
The article benchmarks a Spring Boot 3 service as a GraalVM native image, a traditional JAR, and Go and Rust versions, showing the native binary starts in under a second with ~70 MB memory and 7 k requests/s, the JAR needs seconds and 200 MB, while Go and Rust use 10 MB and 3 MB respectively with throughput, illustrating native images’ fast startup and lower runtime footprint despite longer compilation.
This article explores Java Swing packaging challenges, compares five distribution methods—including GraalVM, JLink, and Exe4J—highlights their pros and cons, and demonstrates a custom WinForm tool that bundles a Swing program with a minimal JRE into a double‑clickable executable.
This article explains the challenges of Java cold start and high memory usage in cloud‑native environments, introduces GraalVM static compilation and a novel static Java Agent solution, and provides step‑by‑step instructions for installing ARMS, configuring dependencies, and achieving fast, observable native images.
This guide explains the challenges of Java cold‑start and high runtime memory in cloud‑native environments, introduces GraalVM static compilation and a novel static Java Agent instrumentation solution, and provides step‑by‑step instructions—including dependency installation, Maven configuration, pre‑run collection, and native image building—to enable observable, high‑performance Java applications.
This article explains how Spring Boot 3.2 can be accelerated with Class Data Sharing, virtual threads, GraalVM native images, ProblemDetail error handling, and new observability features, providing practical commands and code examples for faster startup, lower memory usage, and richer monitoring.
This article explains how Alibaba Cloud engineers tackled the challenges of long startup times and high memory usage in Java serverless workloads by designing a static Java Agent instrumentation that works with GraalVM Native Image, preserving OpenTelemetry observability while dramatically improving performance.
Mvnd, the Apache Maven Daemon built with GraalVM, runs as a native executable that eliminates JVM startup overhead, reduces memory usage, and parallelizes module builds, delivering up to several‑fold speed improvements over traditional Maven, as demonstrated with real‑world performance tests and simple installation steps.
GraalVM Native Image now supports Native Memory Tracking (NMT), allowing developers to monitor off‑heap memory allocations, compare Java and native execution, integrate with JFR, and assess performance impact through detailed reports and experimental events.
mica-mqtt is a lightweight, low‑latency, high‑performance open‑source MQTT component built on Java AIO, offering full MQTT v3.1/v3.1.1/v5 support, WebSocket, REST API, client/server capabilities, clustering via Redis, GraalVM native compilation, Spring Boot starter integration, and extensive customization for IoT and messaging scenarios.
This article analyses the challenges of protecting intellectual property in B2B Java applications, reviews existing obfuscation and encryption tools, and proposes a lightweight Maven‑based encryption plus javaagent decryption scheme that secures both proprietary code and third‑party dependencies while keeping performance impact below five percent.
This article walks through the One Billion Row Challenge, explaining the problem, baseline solution, and a series of progressive Java optimizations—from parallel streams and better JVMs to custom hash tables, Unsafe, SWAR, and statistical tuning—that shrink execution time from minutes to under two seconds.
Oracle announced preview support for JavaScript‑based stored procedures in MySQL, showing how to write, call, and debug them using GraalVM, while industry reactions highlight both excitement and concerns about mixing languages in database logic.
Oracle’s MySQL 8.2 preview introduces JavaScript stored procedures powered by GraalVM, allowing developers to write JavaScript or Java code inside the database, but the feature remains a technical preview with performance benefits, debugging support, and cautions about production use and global variable behavior.
The article examines the One‑Billion‑Row benchmark challenge, showcasing a GraalVM‑powered Java solution and comparing its performance against dozens of languages—from C and Rust to Python and JavaScript—highlighting stark speed differences and the impact of AOT and JIT compilation techniques.
Spring Boot 3.2 now fully supports Java 21, Project Loom virtual threads, and GraalVM native images, and this guide walks through installing Java 21‑GraalVM, configuring virtual threads, building sample controllers, async and scheduled tasks, and creating a native executable to achieve faster startup and lower memory usage.
This article demonstrates how to use Spring Boot 3.2 with Java 21, enabling virtual threads and GraalVM native images, providing step‑by‑step setup, configuration, and sample code for controllers, async tasks, and scheduled jobs, and discusses performance benefits and considerations.
This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step instructions, configuration details, and runnable code examples that showcase building, running, and profiling a Spring Boot application with these modern technologies.
This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, guiding you through installation, configuration, sample code, and performance benefits of running a Spring application on virtual threads and native compilation.
This article demonstrates how to use Spring Boot 3.2 together with Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step setup, configuration, and code examples for controllers, async tasks, scheduled jobs, and native compilation.
This article introduces Spring Native, explains how it uses GraalVM to compile Spring Boot apps into native executables with sub‑100 ms startup and lower memory usage, provides step‑by‑step setup and Docker build instructions, and compares its performance against traditional Spring Boot launches.
The new GraalVM for JDK 21 brings full virtual‑thread support, native‑image capabilities without preview flags, performance improvements, early Java Vector API optimizations, and a high‑performance runtime for Java and other languages, with download links and additional resources for developers.
This article explains why Java applications should migrate from JDK 8 to JDK 17, introduces GraalVM native‑image technology, provides detailed upgrade procedures, Maven configuration, code examples, and a summary of performance benefits and typical issues encountered during the migration.
maven‑mvnd, an Apache‑backed build tool that embeds Maven and leverages GraalVM, speeds up Java project compilation by reusing JVM processes, caching plugin classloaders, and retaining JIT‑generated code, with parallel module builds and simple mvn‑to‑mvnd command substitution, though JDK version quirks may require workarounds.
Oracle GraalVM’s new release for JDK 17 and JDK 20 adds free‑to‑use native‑image features—including profile‑guided optimizations, G1 GC, object‑header compression, ML‑driven PGO, and SBOM support—delivering up to 46% faster startup, 2‑3× lower memory usage, and up to 1.6× higher peak throughput compared with traditional JIT, while also introducing new tooling such as native‑image bundles, build reports, enhanced AWT support, and experimental monitoring.
The article examines Java's 27‑year history, comparing its performance, startup time, and memory usage against modern languages and cloud‑native demands, while detailing JDK feature releases, module system, garbage collectors, AOT compilation, virtual threads, value types, GraalVM, and emerging frameworks to assess Java's relevance today and tomorrow.
The recent GraalVM community survey reveals that 65% of respondents already use or plan to use GraalVM in production, with native image creation, polyglot APIs, and Java being the most popular use cases, while challenges include library support and better error diagnostics.
This article provides a comprehensive roundup of recent Java ecosystem developments, including new JDK 20 and 21 builds, updates to OpenJDK drafts, releases of GraalVM, Spring Framework, Quarkus, Micronaut, JobRunr, MicroStream, Hibernate, Apache projects, and related community events.
Spring Native beta lets developers compile Spring Boot applications into GraalVM native images, delivering sub‑100 ms startup, peak performance and reduced resource usage, while providing Maven/Gradle plugins, AOT conversion, and seamless integration with start.spring.io for both Java and Kotlin projects.
This article explains how to select the proper base image (Alpine or Debian), decide between JDK and JRE, choose Oracle or OpenJDK, handle graceful shutdown signals in Docker, configure memory limits across JDK versions, manage DNS caching, and optionally compile Java applications to native binaries with GraalVM.
This article explains how to optimize memory usage and startup time of Spring Boot microservices on a limited-resource server by configuring JVM parameters, installing GraalVM, and building native images with Spring Native and Docker Buildpacks, providing step‑by‑step instructions and code examples.
This guide walks through setting up GraalVM on Ubuntu, configuring environment variables, handling native-image agent pitfalls, fixing H2 database class‑loading issues, and finally producing a compact native executable for a Solon‑based Java service with memory‑optimisation tips.
This article walks through the memory‑shortage problem of deploying multiple Spring Cloud Alibaba microservices on a single 2‑CPU 4‑GB server, explains JVM tuning, introduces Spring Native, and provides a step‑by‑step guide—including environment setup, GraalVM installation, Maven configuration, and Docker image building—to achieve millisecond‑level startup and dramatically reduced memory usage.
This tutorial walks through installing GraalVM, configuring Spring Native, building a native Spring Boot application using Buildpacks or the native‑image plugin, creating Docker containers, and comparing startup speed and memory usage against traditional Java execution, providing full pom.xml examples and official documentation links.
The mica-auto Spring Boot starter tool leverages Java Annotation Processors to automatically generate essential configuration files such as spring.factories, AutoConfiguration.imports, aot.factories, and spring‑devtools.properties, supporting Spring Boot 2.7+ and 3.0, and simplifying native image builds with GraalVM.
This article provides a comprehensive step‑by‑step migration guide for upgrading Spring Boot applications to version 3.0, covering JDK updates, dependency assessment, configuration changes, Jakarta EE package renaming, key feature alterations, and practical code snippets.
Spring Boot 3.0, the first major release since 2.0, introduces Java 17 baseline, GraalVM native image support, enhanced observability with Micrometer, and Jakarta EE 10 compatibility, while providing a detailed migration guide for upgrading from earlier Spring Boot versions.
The article examines Java's performance and memory challenges in cloud‑native environments, introduces GraalVM and its components—Graal Compiler, Substrate VM, Truffle, and Sulong—explains how they enable ahead‑of‑time compilation, multi‑language support, and significant startup and memory improvements, and provides technical details and examples.
Spring Framework 6.0.0 has been officially released, introducing a Java 17+ baseline, migration to Jakarta EE 9+ namespaces, support for the latest Jakarta EE 10 APIs, AOT compilation for GraalVM native images, virtual threads via Project Loom, and enhanced HTTP client observability.
This roundup covers the latest Java developments, including JEP 434’s move to candidate status, second‑preview updates for virtual threads and structured concurrency, the JDK 20 release schedule, and new releases across Spring, GraalVM, Open Liberty, Vert.x, TomEE, JReleaser, Hibernate, PrimeFaces, JDKMon, and EclipseCon.
Spring Boot 3.0 RC1 introduces 135 enhancements, native executable support via Maven/Gradle plugins, migration to Jakarta EE 9, Java 17 baseline, and new features such as flexible Spring Data JDBC auto‑configuration, Prometheus example auto‑configuration, and Log4j2 improvements, with full details in the release notes.
Spring Framework 6.0 RC1 introduces Java 17+ requirement, migration to Jakarta EE 9+, AOT compilation support, virtual‑thread integration, and updated compatibility with Tomcat 10, Jetty 11, and Hibernate 6.1, while adding new HTTP client features and observability enhancements.
Spring Framework 6.0 introduces comprehensive GraalVM AOT support, adding new modules such as GraalVM feature, AOT core, and JavaPoet, along with aot.factories configuration files that enable developers to customize native image generation, replace Spring Native, and manage runtime hints for beans, context, and other components.
This article walks through what Spring Native is, how it uses GraalVM native images to dramatically reduce Spring Boot startup time, and provides a step‑by‑step setup, performance comparison, and troubleshooting tips for building and running native Spring applications.
This article walks through diagnosing memory pressure in a multi‑service Spring Cloud Alibaba project, applying JVM tuning, installing GraalVM and Spring Native, configuring Maven and Docker Buildpacks, and finally building and running a native Spring Boot image that starts in milliseconds and consumes only a few dozen megabytes of RAM.
This tutorial explains how to address memory constraints when deploying multiple Spring Boot microservices on a single 2‑CPU, 4‑GB server by applying JVM tuning, installing GraalVM, configuring Spring Native 0.11.1 with Maven plugins, building native images, and deploying them via Docker, achieving startup times in milliseconds and memory consumption around 28 MB.
This article introduces Spring Native, explains how native images built with GraalVM can reduce Spring Boot startup time to under 100 ms, walks through environment setup, project initialization, Docker image creation, performance testing, and provides troubleshooting tips for common issues.
Phoronix benchmarked OpenJDK versions 8 through 19 alongside OpenJ9 and GraalVM CE on an Intel Core i5‑12600K Ubuntu 22.04 system, revealing varied performance across SciMark, matrix multiplication, LU decomposition, DaCapo, Renaissance, and other tests, with OpenJDK 18/19 often leading in overall scores.
On May 14 the open‑source Fastjson library launched version 2.0.3, adding better compatibility with its 1.x line, native support for JDK 14 records, GraalVM native‑image compatibility, an improved extension mechanism, stronger JSONPath capabilities, Jackson annotation compatibility, and faster deserialization for heavily escaped JSON data.
This article introduces Maven‑mvnd, an Apache‑backed, GraalVM‑powered Maven alternative that speeds up Java builds through daemon processes and JVM optimizations, explains its installation (including Homebrew on macOS and JDK version considerations), demonstrates usage, and discusses performance benefits and known issues.
This article explains the root causes of Java cold‑start latency, describes how static compilation with GraalVM removes JVM initialization and JIT overhead, and shows performance comparisons that demonstrate near‑instant startup for serverless Java applications.
mica‑mqtt, built on t‑io, offers a simple, low‑latency, high‑performance open‑source MQTT component that integrates easily into existing services, supports multiple protocols and deployment scenarios, and includes Spring Boot starter, GraalVM compilation, and Redis‑based clustering for robust IoT solutions.
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.
