java

This study addresses the lack of systematic evaluation of energy consumption impacts in software stack upgrades, which hinders sustainable operational decisions. It presents the first comprehensive quantification of energy differences across combinations of Spring Boot and JVM versions on multiple platforms. Through automated benchmarking and precise power measurements, the work demonstrates that significant energy savings can be achieved without modifying application code by leveraging newer JVM features—such as virtual threads introduced in Java 21 and 23. The findings reveal that judicious selection of software stack versions can substantially reduce energy consumption, offering empirical evidence and practical guidance for greener software upgrades.

Existing architecture recovery techniques perform poorly in migrating monolithic Java systems to the Java Platform Module System (JPMS). To address this, we propose ClassLAR, a lightweight module recovery approach. ClassLAR innovatively integrates semantic and structural information from package and class names—leveraging only fully qualified class names—by encoding naming semantics via a pre-trained language model and applying hierarchical clustering coupled with module similarity metrics (e.g., Modularity, Adjusted Rand Index). Crucially, it infers semantically coherent module boundaries without requiring source-code parsing or execution. Evaluated on 20 widely used Java projects, ClassLAR consistently outperforms state-of-the-art methods: it achieves significantly higher module partition quality while accelerating runtime by 3.99×–10.50×. This establishes a novel, low-overhead paradigm for embedding architectural intent into JPMS migration.

This study addresses the misleading nature of Java microbenchmarks conducted in isolation, which often yield distorted performance profiles due to the JVM’s dynamic compilation mechanisms—particularly inaccurate runtime profiling data such as branch probabilities and call-site types. The paper presents the first systematic investigation into profiling biases introduced by the absence of realistic contextual information in microbenchmarks, demonstrating that such distortions persist even when benchmarks strictly adhere to JMH best practices. By integrating JMH with JVM dynamic compilation internals and runtime profiling techniques, the authors empirically analyze representative cases of benchmark misinterpretation and propose an enhanced set of practical guidelines. These recommendations substantially improve the representativeness and reliability of microbenchmark results with respect to real-world application performance.

This work addresses the complexity and error-proneness of the Java Memory Model (JMM) and the lack of automated verification for new proposals. The authors introduce jMT, the first tool capable of automatically verifying the multi-execution semantics of the JMM. jMT constructs well-formed execution graphs from a single-execution model and employs causal analysis to derive multi-execution semantics, enabling program-level validation of the JMM’s correctness, its compatibility with standard compiler optimizations, and its consistency with existing compilation schemes. Evaluated on 169 litmus tests, jMT successfully uncovers several latent issues in current JMM specifications, offering critical empirical support for both JMM design and compiler implementation.

Dynamic Software Updates (DSUs) reduce downtime, improve security, and accelerate iterative development; however, existing research lacks systematic, empirical comparisons of DSU techniques in the Java ecosystem—particularly regarding supported code-change types and associated runtime resource overhead. Method: This paper presents the first cross-cutting evaluation of mainstream Java DSU mechanisms—including bytecode hot-swapping, class redefinition, and proxy injection—using micro-benchmarks and system-level monitoring to quantify CPU and memory overhead across representative change scenarios (e.g., method body modification, field addition/removal). Contribution/Results: We propose a “change capability–resource cost” analytical framework that empirically correlates update expressiveness with runtime overhead, filling a critical gap in evidence-based DSU comparison. Our findings provide data-driven guidance for industry practitioners selecting lightweight, secure, and evolution-aware hot-update solutions aligned with real-world maintenance requirements.

This study addresses the absence of benchmarks for evaluating behavior-preserving migrations of enterprise Java applications across frameworks such as Spring, Jakarta EE, and Quarkus. The authors introduce the first systematic benchmark comprising 34 applications, 102 variants, and 204 directed migration tasks, along with an end-to-end correctness validation mechanism based on executable oracles that ensures functional equivalence through compilation, containerized deployment, and interface behavior testing. Experimental results reveal that even the most advanced coding agents achieve only a 15.3% pass rate for single-layer migrations and 12.2% for full-application migrations, with merely one of the 204 tasks attaining complete behavioral equivalence. The study further uncovers significant asymmetries in migration difficulty across framework directions and architectural layers and identifies recurring failure patterns spanning build, deployment, and testing phases.

This work addresses the limited support of current large language models (LLMs) for the software design phase, where accurately translating requirements into implementable designs remains a challenge. To bridge this gap, we introduce DesBench, the first evaluation benchmark specifically tailored for software design, comprising 30 manually curated Java projects that include requirements documents, design models, implementation code, and test cases. Using DesBench, we systematically assess mainstream LLMs across three key tasks: design-aware code generation, object-oriented modeling, and acceptance test design. Our findings reveal that LLMs struggle to produce correct code when no design or only high-level design is provided, exhibit significant deficiencies in modeling class relationships, yet generate acceptance tests that achieve code coverage comparable to human-written ones.

This work addresses the challenge of detecting cross-language compilation bugs in multi-language JVM applications, which arise from semantic discrepancies between languages and are largely overlooked by existing compiler testing approaches focused on single-language settings. To bridge this gap, the authors propose the first differential testing framework tailored for cross-language JVM compilation. The approach leverages Kotlin’s unified intermediate representation (IR) to synthesize cross-language test programs and introduces seven custom mutation operators to enhance test diversity. This methodology enables the first systematic differential testing of multi-language JVM compilation scenarios, uncovering 32 confirmed bugs across five major compilers—Kotlin, Groovy, Scala 2/3, and Java. The findings demonstrate that the framework effectively exposes and mitigates semantic inconsistencies at language boundaries, significantly improving compiler reliability.

Accurately predicting the energy consumption of Java methods during early development stages remains challenging, hindering effective energy-efficiency optimization. This study systematically demonstrates for the first time that models relying solely on static code metrics exhibit extremely poor predictive performance (R² ≈ 0). To address this limitation, the authors propose a regression approach that integrates 33 static features with lightweight dynamic execution time measurements. Experimental results show that incorporating execution time substantially improves prediction accuracy, with the best-performing model achieving an R² of 0.46. The analysis further identifies execution time, internal method invocation frequency, and cyclomatic complexity as the most influential predictors, offering actionable insights for early-stage energy-aware software development.