Generating domain models from requirements is a vital and complex challenge in automated software engineering. Although large language models (LLMs) have exhibited significant competence in this area, their propensity for hallucination frequently results in models that are redundant, inconsistent, or structurally unsound. To enhance the quality of automatically generated models, this paper introduces MoRe, an LLM-based approach to domain model generation with self-refinement. Within our approach, an LLM is first tasked with producing an initial domain model draft. Subsequently, a hybrid refinement-combining LLMs with a rule-based scanner-is employed to identify and correct common issues in the model. An empirical study was conducted using 30 domain modeling problems and four open-source LLMs. The results indicate that MoRe significantly improves the quality of generated domain models. This paper advocates for incorporating a self-refinement phase as a standard component in any automated modeling workflow.

In modern software development, templates are widely used to generate artifacts, enhancing productivity and consistency. However, developers often face a tedious run-modify-run loop to verify template correctness, as outputs are only inspectable after execution. This issue is exacerbated when templates involve complex logic, highlighting the need for a solution that supports both artifact generation and user-friendly modifications. We propose BIT2, a framework enabling direct manipulation of plain-text output to modify template programs. A key challenge is that plain-text output lack structural information, making it difficult to map updates back to the template. BIT2 addresses this by generating computation-structured output, preserving the underlying logic, and supporting update operations (insertion, replacement, deletion) with carefully designed fusion semantics. Our implementation, written in TypeScript (18,000 lines of code), is available as an NPM module, complemented by a VSCode plugin, LiveT, for seamless template editing. Experimental results demonstrate that BIT2 achieves efficient evaluation and supports diverse update scenarios, significantly enhancing expressiveness in template development.

Smart contracts are self-executing programs deployed on blockchains to enable automated and trustless transactions without intermediaries. However, existing smart contracts (e.g., those written in Solidity) resemble general-purpose programs rather than legal contracts, making them incomprehensible to non-technical users. To address this limitation, we present SpeSC + , a domain-specific language (DSL) designed for both readability and legal expressiveness. SpeSC + features a natural-language-like syntax and integrates domain-specific concepts for contractual logic, such as time expressions, parties and authorizations, and obligations and privileges. Unlike existing works that focus on utilizing natural languages for specification, we equip SpeSC + with a formally defined, Turing-complete semantics for precise execution, covering the entire execution process of a legal contract. We evaluated SpeSC + ’s expressiveness by implementing 35 real-world legal contracts across 10 business domains and 5 canonical Solidity examples. A controlled user study further demonstrated SpeSC + ’s superior readability over Solidity, particularly for users without programming expertise, without compromising expressiveness. We also measured the gas usage and detected vulnerabilities in the Solidity programs generated by the SpeSC + code generator. The evaluation results suggest that SpeSC + lowers the barrier to creating and understanding legally enforceable smart contracts.

Efficient linear solvers are essential for large-scale reservoir simulation, yet the performance of conventional constrained pressure residual (CPR) preconditioners may deteriorate when well-reservoir coupling becomes strong. This study investigates the CPRW preconditioner as implemented in the open-source OPM Flow simulator (version 2024.10), an enhanced CPR variant that incorporates key well-related variables (e.g., bottom-hole pressure) into the coarse-level pressure correction. The paper provides a structural block-matrix formulation that clarifies the algebraic differences between classical CPR and CPRW. Rather than introducing a new preconditioning concept, the focus is on assessing the applicability, robustness, and performance of the existing CPRW formulation across a range of reservoir benchmark scenarios. Numerical experiments on nine models, including black-oil, highly heterogeneous, thermal, multisegment well, and real field-scale cases, show that CPRW improves linear convergence in strongly coupled settings. Key findings include: (1) CPRW reduces linear iteration counts relative to classical CPR in several cases with strong well-reservoir interaction and pronounced near-well nonlinearities; (2) when combined with algebraic multigrid and suitable fine-level smoothing strategies, it yields favorable runtime reductions and parallel performance in the tested cases; and (3) its modular structure leverages existing sparsity while preserving a coarse-level operator compatible with AMG, introducing only a small number of extra nonzero matrix entries associated with the well, enabling efficient integration into industrial simulators and supporting scalable parallel execution. These results position CPRW as a robust and scalable preconditioner for reservoir simulation workflows.

Automated root cause analysis (RCA) with large language models (LLMs) has drawn growing attention. Today, SREs typically automate RCA with LLMs in one of two ways: directly using a general-purpose agent (e.g., Codex or Claude Code) for diagnosis, or building a specialized RCA agent from scratch. As mainstream general agents grow more capable and iterate quickly, our quantitative study finds that the former now often surpasses the latter. Its accuracy, however, still falls short of production needs, and this gap stems mainly from the external adaptation layer outside the agent's general capabilities, namely the harness. We therefore argue that LLM-based RCA should focus on this external harness, reusing the strong general capabilities of a modern agent rather than rebuilding an agent from scratch. A key capability of such a harness is to self-evolve, accumulating system-specific experience from past diagnoses so that it gets better the more it is used. We introduce OpsHarness, a self-evolving RCA harness that turns diagnosis experience into reusable expertise. Its data plane combines layered operational knowledge with an idea-card tool library, while its control plane coordinates setup, diagnosis, evolution, and verification. During evolution, OpsHarness contrasts successful and failed trajectories, converts their evidence into atomic proposals, and admits updates only through a dual-gate verification process designed to prevent overfitting and regression. Across two public benchmarks and an industrial deployment, OpsHarness achieves 59.0% top-1 accuracy, improving over a bare general agent by 63.4% and over baseline RCA agents by 4.02×.

Recently, large language models (LLMs) are extensively utilized to enhance development efficiency, leading to numerous benchmarks for evaluating their performance. However, these benchmarks predominantly focus on implementation, overlooking the equally critical aspect of software design. This gap raises two pivotal questions: (1) Can LLMs handle software design? (2) Can LLMs write code following the specific designs? To investigate these questions, this paper proposes DesBench, a design-aware benchmark for evaluating LLMs on three software design-related tasks: design-aware code generation, object-oriented modeling, and the design of acceptance test cases. DesBench comprises 30 manually crafted Java projects that include requirement documents, design models, implementations, and acceptance tests, amounting to a total of 30 design models, 194 Java classes, and 737 test cases. We evaluated seven state-of-the-art LLMs, including three DeepSeek R1, two Qwen2.5, and two GPT models, using DesBench. The results reveal that LLMs remain significantly challenged by the intricacies of software design: (1) For code generation, LLMs struggle to produce correct implementations when provided with only high-level or no designs. (2) In object-oriented modeling, while LLMs can accurately identify objects and classes, they face challenges in defining operations and inter-class relationships. (3) Acceptance test cases generated by LLMs from functional requirements achieve code coverage quality comparable to those written by humans. Our research highlights the current limitations of LLMs in managing software design and calls for further investigation into new design methodologies and languages suitable for LLM-based development.

Context: Efficient version management of models in model-driven software engineering is vital for modeling tools, necessitating model matching, differencing, and merging to incorporate various model versions. Although similarity-based matching is the most general method, its computational complexity escalates at a cubic rate with the number of elements. Objective: This paper introduces StEqMatch, a subtree-equivalence-based approach to accelerate similarity model matching, inspired by the observation that consecutive version changes typically impact only a small portion of a model. Methods: StEqMatch initially decomposes a model into a series of subtrees. Rather than performing element-wise matching directly, our approach tries to find equivalent (i.e., either identical or closely similar) subtrees, representing the unchanged portion of a model, thus enabling quick pairing of elements within these subtrees. To effectively identify equivalent subtrees, this paper develops two hash functions for equality and similarity comparison of model trees. Results: Experiments using open-source Ecore and UML models indicate that StEqMatch is 1.27 to 22.5 times faster on average compared to the state-of-the-art model matching tool while reducing the error rates in most cases. Conclusion: StEqMatch combines subtree matching and element-wise matching, and can improve the efficiency and the quality of similarity-based model matching.

Bidirectional live programming is a programming paradigm that enhances the developer experience by allowing direct modifications to the output, with changes instantly reflected back to the source program. Existing operation-based approaches allow modifying the constant values and expressions of programs, while they lack control over modifications originating from multiple updatable locations. To control the updatability of the source program, our approach introduces non-updatable expressions, which guide the fusion of updates to the intended locations. The correctness properties, GetPut and WeakPutGet, ensure output consistency. We have implemented a prototype, FuseSVG, and tested it with 14 nontrivial SVG-drawing benchmarks, demonstrating the effectiveness of our approach.

Template-based and LLM-based code generation are both key enablers of automated software development. The former provides correctness guarantees but are rigid for complex requirements, whereas LLMs offer high flexibility at the risk of producing faulty code.This paper proposes iEcoreGen, a hybrid approach that integrates Eclipse Modeling Framework (EMF) and LLMs. In EMF, an Ecore model defines a system structure and acts as a blueprint for code-generation.iEcoreGen decomposes requirements to derive operation specifications, uses EMF's template-based generator to produce initial Java code, and serializes specifications into docstrings. LLMs are then invoked to complete and fix unimplemented methods. We assessed iEcoreGen on twenty code-generation tasks across five LLMs. It surpasses LLM-only baselines on pass@k and performs on par with them on compilation@k. An ablation study clarified the contribution of each component of iEcoreGen. Overall, the findings indicate that LLM-enhanced model-driven development is a promising path toward more efficient software automation.

Reservoir numerical simulation is crucial for advancing research and development in petroleum engineering. To obtain high-precision spatial and temporal simulation results, a great amount of time and computational resources are needed. Parallel computing addresses this problem by distributing computational workloads and memory requirements across multiple processors. It enables large-scale and high-fidelity simulations and reduces time costs. In this paper, we review existing parallel computing for large-scale reservoir numerical simulation. The paper is achieved by conducting a systematic literature review published between 1990 and 2024. Using the PRISMA guideline, 134 supporting studies are selected for detailed extraction. The key contributions of this paper are threefold: (1) classification and analysis of numerical methods (including discretization methods, nonlinear methods, and linear iterative solvers and preconditioner methods); (2) an in-depth discussion on parallel techniques in high-performance computing (HPC), such as parallel programming models, load balancing, communication optimization, and GPU acceleration; and (3) an outline of software implementations, particularly solvers and reservoir simulators. In conclusion, developing efficient, robust, and scalable linear solving tools is key to reservoir simulation. We compare available preconditioner options and summarise the current state of the art in linear solving tools. Meanwhile, CPU and GPU parallel acceleration techniques have been rapidly developed. These emphases will provide a theoretical foundation and practical guidance for optimizing linear solution processes in the future.

Model-driven development is a model-centric software development paradigm that automates the development process by converting high-level models into low-level code and documents. To maintain synchronization between models and code/documents — which can evolve independently — this paper introduces BIT, a bidirectional language that can serve as a conventional template language for model-to-text transformations. However, a BIT program can function as both a printer, generating text by filling template holes with values from the input model, and a parser, putting parsed values back into the model. BIT comprises a surface language for better usability and a core language for formal definition. We define the semantics of the core language based on the theory of bidirectional transformation, and provide the translation from the surface to the core. We present the proof sketch of the well behavedness of BIT as a formal evidence of soundness. We also conduct three case studies to empirically demonstrate the expressiveness and the effectiveness of BIT. Based on the proof and the case studies, BIT covers the major features of existing template languages, and offers sufficient expressiveness to define real-world model-to-text transformations that can be executed bidirectionally and incrementally.

The spatially resolved stochastic cluster dynamics (SRSCD) method is one of the most important methods for simulating the time-evolution of spatially correlated microstructures in irradiated materials. It is a kinetic Monte Carlo-based method for stochastically evolving integer-valued populations of defects within multi finite volume elements according to reaction rates. However, the increasing spatial scale and complexity of the simulated systems have exceeded the capabilities of serial SRSCD. To extend SRSCD to simulate large-scale complex systems, we propose a massively parallel SRSCD method in this paper and implement the program named MISA-SLSCD. It contains four contributions: (1) a dynamic Defect-Reaction Tree data structure to efficiently store and update millions of defect species and reactions; (2) a double-grouping search strategy to speed up the search for defects and reactions; (3) an adaptive synchronous algorithm to balance the accuracy and efficiency of simulations; and (4) an on-demand communication strategy to eliminate communication redundancy. A series of numerical simulation results show that our method has high accuracy in simulating damage accumulation in irradiated materials and obtains a good performance of over 90% parallel efficiency on 32, 000 CPU cores with a 32 million-volume-element system.Program summaryProgram Title: MISA-SLSCDCPC Library link to program files: https://doi .org /10 .17632 /ctmn5f5bzk .1Code Ocean capsule: https://codeocean .com /capsule /8351487 Licensing provisions: BSD 3-clauseProgramming language: Fortran90Nature of problem: Behaviours of defects in irradiated materials are typically space-dependent long-term dynamical processes, and spanning multiple orders of magnitude in space (similar to nm to m) and time (similar to mu s to years). The SRSCD method is an important method for simulating the time-evolution of spatially correlated microstructures in irradiated materials. However, the increasing spatial scale and complexity of the simulated systems have exceeded the capabilities of serial and existing parallel versions. It is necessary to develop new massively parallel method and program to extend SRSCD to simulate large-scale complex systems.Solution method: To extend SRSCD to simulate large-scale complex systems, we propose a massively parallel SRSCD method in this paper and implement the program named MISA-SLSCD. It contains: (1) a dynamic Defect Reaction Tree data structure to efficiently store and update millions of defect species and reactions; (2) a double grouping search strategy to speed up the search for defects and reactions; (3) an adaptive synchronous algorithm to balance the accuracy and efficiency of simulations; and (4) an on-demand communication strategy to eliminate communication redundancy.

Similarity-based model matching is the cornerstone of model versioning. It pairs model elements based on a distance metric (e.g., edit distance). However, calculating the distances between elements is computationally expensive. Consequently, a similarity-based matcher typically suffers from performance issues when the model size increases. Based on observation, there are two main causes of the high computation cost: (1) when matching an element p, the matcher calculates the distance between p and every candidate element q, despite the obvious dissimilarity between p and q; (2) the matcher always calculates the distance between p and q' , even though q and q' are very similar and the distance between p and q is already known. This paper proposes a dual-hash-based approach, which employs two entirely different hashing techniques—similarity-preserving hashing and integrity-based hashing—to accelerate similarity-based model matching. With similarity-preserving hashing, our approach can quickly filter out the dissimilar candidate elements according to their similarity hashes computed using our similarity-preserving hash function, which maps an element to a 64-bit binary hash. With integrity-based hashing, our approach can cache and reuse computed distance values by associating them with the checksums of model elements. We also propose an index structure to facilitate hash-based model matching. Our approach has been implemented and integrated into EMF Compare. We evaluate our approach using open-source Ecore and UML models. The results show that our hash function is effective in preserving the similarity between model elements and our matching approach reduces time costs by 20–88

Many bidirectional programming languages, which are mainly functional and relational, have been designed to support writing programs that run in both forward and backward directions. Nevertheless, there is little study on the bidirectionalization of object-oriented languages that are more popular in practice. This paper presents the first bidirectional object-oriented language that supports programmatic and direct manipulation of objects. Specifically, we carefully extend a core object-oriented language, which has a standard forward evaluation semantics, with backward updating semantics for class inheritance hierarchies and references. We formally prove that the bidirectional evaluation semantics satisfies the round-tripping properties if the output is altered consistently. To validate the utility of our approach, we have developed a tool called BiOOP for generating HTML documents through bidirectional GUI design. We evaluate the expressiveness and effectiveness of BiOOP for HTML webpage development by reproducing ten classic object-oriented applications from a Java Swing tutorial and one large project from GitHub. The experimental results show the response time of direct manipulation programming on object-oriented programs that produce HTML webpages is acceptable for developers.

The reactor is an extreme environment of high temperature, high pressure, and high radiation dose. Damage accumulates in structural materials over service time. It will eventually lead to material failure, such as hardening, embrittlement, and swelling. The radiation damage accumulation is an inherent, complex, and multiscale process, which has been studied extensively with multiscale modeling and simulation methods. The rapid development of high-performance computing makes it possible to accurately operate multiscale simulation for the microstructure evolution of irradiated reactor materials. The European Union, the USA, and China have put great effort into this, and many related works have been carried out. This paper first outlines the basic application of multiscale modeling and simulation technology in understanding the effects of radiation on reactor structural materials. Then, some relevant projects carried out by the USA, the European Union, and China in recent years are summarized. Next, the paper focuses on three widely used simulation techniques at different scales: molecular dynamics, kinetic Monte Carlo, and cluster dynamics. For each method, some key developments in algorithms and computer implementations are reviewed. Finally, the comparison between them is discussed.

随着互联网、物联网、云计算等新计算平台、新应用模式及智能化等新软件模式的广泛运用,软件系统内外各种来源的非确定性不断增强.从软件系统内部的不确定性来看,并发程序是一类典型的非确定性软件系统.并发程序由于其随机性高的特点,容易导致并发缺陷且难以调试.从软件系统外部的不确定性来看,软件所处的网络环境和所服务的用户需求变得更加动态多变,这就要求软件系统能够主动应对这些动态变化.具有自适应和持续演化能力的软件系统需要在环境和需求的自动感知与理解、适应行为的自主决策以及适应行为的精准实施等环节处理各种不确定性,以保障系统能够持续、稳定地提供服务.从软件构造途径的不确定性来看,包含深度神经网络部件的数据驱动智能化软件系统是另一类非确定性软件系统,其非确定性来自于机器学习模型的归纳本质.此类系统日益应用于一些安全相关的领域,这就对其软件质量提出了更高的要求.本专题关注软件质量保障中非确定性问题所面临的挑战以及相关软件质量保障技术.

提出一种基于扩展权限组合的Android应用程序隐私数据泄露检测方法.首先扩展Kirin安全规则集,然后从源代码层和字节码层分别提取Android应用程序申请的危险权限组合,最后动态检测是否存在隐私数据泄露的情形,并开发了支持工具DroidProtector.采用一组Android应用程序进行实验评估,结果表明,该方法能检测出更多类型的隐私数据泄露问题,DroidProtector在大幅度提高隐私数据泄露检测有效性的前提下仅引入了较小的性能开销.

When building enterprise applications on Java frameworks (e.g., Spring), developers often specify components and configure operations with a special kind of XML files named “deployment descriptors (DD)”. Maintaining such XML files is challenging and time-consuming; because (1) the correct configuration semantics is domain-specific but usually vaguely documented, and (2) existing compilers and program analysis tools rarely examine XML files. To help developers ensure the quality of DD, this paper presents a novel approach-XEDITOR-that extracts configuration couplings (i.e., frequently co-occurring configurations) from DD, and adopts the coupling rules to validate new or updated files. Xeditor has two phases: coupling extraction and bug detection. To identify couplings, Xeditor first mines DD in open-source projects, and extracts XML entity pairs that (i) frequently coexist in the same files and (ii) hold the same data at least once. Xeditor then applies customized association rule mining to the extracted pairs. For bug detection, given a new XML file, Xeditor checks whether the file violates any coupling; if so, Xeditor reports the violation(s). For evaluation, we first created two data sets with the 4,248 DD mined from 1,137 GitHub projects. According to the experiments with these data sets, Xeditor extracted couplings with high precision (73%); it detected bugs with 92% precision, 96% recall, and 94% accuracy. Additionally, we applied Xeditor to the version history of another 478 GitHub projects. Xeditor identified 25 very suspicious XML updates, 15 of which were later fixed by developers.

In this paper, we present a new self-destructing data system, called retrograde storage. This system can randomly store messages into a storage pool built on frequently colliding hash table (FCHT) as an alternative way of DHT, and each message will be covered promptly after the expiry of validity period. This approach makes the message unrecoverable by multiple-pass Gutmann method and supports general secret sharing or encryption with counting control for personal data privacy. Moreover, we give a fundamental mathematical model of birth-death processes, in which we provide a detailed performance analysis by some theorems, including erasure distribution, recovery probability, secure erasure time, capacity of recycle pool. Experimental results indicated that our system is more efficient and accurate for controlling message self-destruction cycle, and makes it hard or impossible to recover data in a forensic investigation.