Numerical computation rests on the addition, subtraction, multiplication and division of real numbers. Data types with these operations can be analysed algebraically and logically by the theory of common meadows: a common meadow is an enrichment of a field with a partial division operation that is made total by assuming that division by zero takes a default value ⊥ adjoined to the field. Common meadows have an equational axiomatisation that supports key algebraic laws for calculation and reasoning. We discuss defining other partial functions on numerical data types based on common meadows. As a case study, we explore methods to define entropy and other information measures. To a common meadow of real numbers we add a binary logarithm log2(−) that we assume to be total with log2(p)=⊥ for p ≤ 0. With log2 and other auxiliary operations, such as a left-biased multiplication ∘ × and sign function s(−), we form data types to define entropy measures for all inputs by formulae that are simple terms built from the operations of the data types, and without ‘conventions’ to avoid partiality.
Technical debt (TD) refers to suboptimal code resulting from compromises made by developers to meet business budgets or time constraints. Existing studies mainly focus either on code or comments, which restricts their applicability. Additionally, current research often overlooks the granularity of TD, which can lead to inaccurate identification and inefficient remediation of technical debt. To address these challenges, this paper introduces TDD-TCNN, a novel deep-learning approach for method-level TD detection through source code and comments from multiple perspectives. We first collect method-level source code and comments from nine open-source projects to construct a large method-level technical debt dataset, containing 103,006 validated Java methods, all of which have undergone thorough manual verification. Afterward, we use the dataset to train a deep learning model combining Convolutional Neural Network and Transformer for method-level TD detection, integrating local syntactic features with global contextual dependencies from code snippets to enhance accuracy and robustness. Experimental results demonstrate our approach achieves state-of-the-art performance, with precision of 83.26%, recall of 80.84%, and F1-score of 81.92%. This work provides developers with actionable code quality improvement suggestions through precise TD localization at the method level.
Software defect prediction is an important technique for improving software quality and reducing maintenance costs. In recent years, neural network based graph representations have attracted widespread attention in defect prediction for their ability to capture both structural and semantic features of source codes. However, existing studies largely focus on learning effective graph representations, with little systematic analysis of how different program graphs and graph neural network (GNN) models interact. To address this gap, we present an empirical study that systematically investigates the collaborative effects of 24 unique Graph-GNN combinations on defect prediction performance, which are formed from 6 program graphs (i.e., AST, CFG, CDG, DDG, PDG, and CPG) and 4 GNN models (i.e., GCN, GAT, GIN, and GraphSAGE). Extensive experiments are conducted on 15 versions of 7 open-source Java projects under both within-project defect prediction (WPDP) and cross-project defect prediction (CPDP) settings. Five widely used evaluation measures and the SKESD statistical significance test are applied to compare and rank the performance of different combinations. The results show significant differences in both traditional evaluation measures and effort-aware performance measures among the Graph-GNN combinations, with CFG or CPG combined with GAT or GCN demonstrate the strongest overall performance, suggesting that CFG-GCN is recommended for WPDP, while CPG-GAT is preferred for CPDP. Overall, we provide systematic empirical evidence and practical guidance for selecting effective graph-based GNN models for future defect prediction research.
The incremental development of complex systems requires systematic methods to manage scalability and reduce repetitive effort. In formal methods, this incremental process is naturally supported through refinement, where abstract models are gradually enriched with detail. In this paper, we adopt Event-B as the formal method to explore this process. Developing refinements in Event-B often involves repetitive modeling tasks that can become time-consuming and difficult to manage. Patterns help address this by capturing recurring solutions, making refinements more reusable, systematic, and easier to construct while also providing implicit, up-to-date documentation. Building on this, we investigate how patterns could be used to generate Event-B refinements automatically. The patterns proposed in this paper apply a variety of techniques, such as imposing constraints on the model through weakest precondition or strongest postcondition calculus, superposing counters, and introducing various forms of synchronization or observer-based de-synchronization. We also show how the generated model can be automatically simplified to improve its usability and readability, thereby facilitating subsequent refinement steps. Lastly, we demonstrate the effectiveness of our proposed patterns by revisiting two classic case studies.
The Universal Variability Language (UVL) serves as the primary standard for describing variability models in configurable software systems. SAT/#SAT technology and knowledge-compilation tools, which are commonly used for configuration checking, feature analysis, product counting, and generating uniform random samples, require input in the DIMACS format. This paper presents uvl2dimacs, a C++ tool that converts UVL specifications into DIMACS by providing two complementary techniques: a Tseitin transformation, which limits exponential clause growth, and backbone simplification, which shortens and eliminates clauses by identifying fixed literals. An evaluation of 1533 real-world models from the UVLHub public repository demonstrates the tool’s correctness and effectiveness. Backbone simplification reduces the number of clauses in 99.09% of models (with a median reduction of 40.43%), while the Tseitin transformation achieves clause reduction in only 0.65% of models (but with a median reduction of 83.11% in those cases).
Distributed Stream Processing (DSP) systems execute continuous queries over data streams. To handle workload variations, DSP systems run on clusters of machines and rely on auto-scalers. DSP auto-scalers dynamically adjust the number of parallel instances of operators to support a target rate. State-of-the-art auto-scalers couple CPU and memory scaling, allocating resources as one-size-fits-all packages. This contrasts with operators’ high diversity of requirements for CPU and memory. Justin is an auto-scaler that enables hybrid CPU and memory scaling for DSP operators. Justin monitors both CPU usage and the performance of operators’ storage operations. Its mechanisms enable fine-grain memory allocation for tasks upon a query reconfiguration. The Justin policy identifies individual operators’ memory pressure and decides between adjusting parallelism and/or memory allocation for these operators. Justin is implemented in Apache Flink, extending the Flink Kubernetes Operator and its CPU-only auto-scaler. The artifact includes the code of Justin, the extended Flink Kubernetes Operator, and the evaluation scripts, allowing to reproduce the results of the original publication at IFIP DAIS 2025.
Aggregate computing has been studied for over a decade and is supported by multiple programming frameworks, proving suitable for simulating applications in challenging domains such as smart cities and robot swarms. Project Emerge is a toolchain for practical multi-robot demonstrations based on aggregate computing principles, validated through a public, live, interactive demo at a European Researchers’ Night event. Using a camera system and ArUco markers for localization, we show how the demonstrator coordinates mobile robots to form spatial patterns.
Security patch identification is an essential task in software maintenance, which aims to identify vulnerability-related patches from open-source software (OSS) repositories. Previous works tend to adopt pre-trained models to improve the model performance. These models are often built on billions of parameters and require sufficient computing resources and enough data for supervised fine-tuning, to be applied on downstream classification tasks. However, existing studies mainly address class imbalance through re-sampling or re-weighting strategies. Re-sampling may introduce synthetic noise or disrupt the original distribution of commit data, while fixed re-weighting schemes lack dynamic awareness of the model’s learning status, leading to over-smoothing, unstable optimization, and underfitting. Moreover, increasingly large pre-trained models require substantial computational resources for training and deployment, limiting their practical use in low-resource scenarios. In this work, we propose to boost security patch identification with cumulative learning and knowledge distillation, which aims to address security patch identification in low-resource scenarios while maintaining high-quality identification performance. To alleviate the data imbalance problem, inspired by cumulative learning, we designed a novel adaptive smoothing loss, which dynamically controls the smoothing coefficient a through the training epoch. In the early stage, a higher smoothing coefficient is settled to balance the influence of the majority class, while it is gradually reduced to ensure that the predictions of the minority classes are closely consistent with their true labels in the later stages. To bridge the gap between high-quality identification performance and low computational resources, based on the teacher-student network theory, we adopted the Kullback–Leibler divergence to minimize the difference between the teacher’s distribution and the student’s. The teacher model is further used to generate pseudo-labels for unlabeled data, thereby enhancing the performance of the student model. Experiment results on two open-source datasets demonstrate that our proposed approach not only improves the best baselines by 14.14% and 8.81% on minority class, but also reduces 68% model size. The code and data are shared in https://github.com/AppleMax1992/low-resource-commit-classification.
Context The problem of story point estimation still remains a challenge in agile software development. Statistical methods and conventional machine learning models are not effective in understanding the nuances of the tasks. Even though LLMs excel in analyzing and producing texts that are linguistically complex, their capacity for performing real semantic reasoning is still controversial. As far as effort estimation is concerned, their forecasts will continue to be inaccurate if they lack project-related context. Objective This study aims to investigate the effectiveness of retrieval-based augmented LLMs in the context of estimating story points with increased accuracy compared to traditional statistical approaches and LLMs. Methods In this paper, a Retrieval-Augmented Large Language Model framework that combines semantic similarity search with the text-based inference capabilities of a large language model is presented. To validate the performance of the framework, the TAWOS dataset consisting of 23,313 tasks across 17 projects is used. In the evaluation process, a stratified splitting approach based on the project level is used. To assess the performance, Pred(25), MAE, RMSE, MMRE, and MdMRE metrics are used. To test the significance, the Wilcoxon signed-rank test is applied. Results The proposed model achieves a Pred(25) value of 37.18%, outperforming the world average (34.53%), project median (27.79%), project average (25.67%), and vanilla LLM (27.96%). Furthermore, there is an improvement in MAE and RMSE, implying increased robustness and reduced occurrences of outlier estimation errors. Paired statistical tests show significantly lower values for estimation error (p < 0.001), but effect-size calculations point to negligible and small practical effects, depending on the benchmark. At the project level, performance is project-specific, which implies that the utility of using retrieval-enhanced effort estimation depends on the availability of similar historical efforts. Conclusion Research results indicate that grounding story points for estimation using contextual information via retrieval-based reasoning facilitates effort estimation. The observed improvement is associated with the incorporation of retrieval-based project context. The findings suggest that story point estimation can be more effectively supported when treated as a retrieval-grounded contextual reasoning task rather than as a purely statistical prediction problem.
Cyber-Physical Systems (CPS) combine computational and physical elements, whose inherent complexity continues to motivate research on rigorous and repeatable engineering methods. This paper presents an agent-oriented Model-Driven Development for Cyber-Physical Systems (MDD4CPS) process that ensures end-to-end traceability from high-level intentions to executable code. The proposed approach integrates agent orientation at the Computation-Independent Model (CIM) stage and formalises its transformation through a domain-specific language (DSL) into Platform-Independent (PIM) and Platform-Specific (PSM) models. A formal metamodel defines the DSL structure, notation, and semantics, providing a foundation for consistency and transformation automation across stages. The process is supported by a tool integrated with the web-based modelling platform diagrams.net, enabling automated model-to-model and model-to-code transformations. Its feasibility is demonstrated through a proof of concept applied to greenhouse automation, where the generated software is deployed on Arduino-based units to validate communication and control among sensors and actuators. The proof of concept demonstrates the feasibility of the proposed agent-oriented MDD approach and illustrates how traceability can be preserved from conceptual design to physical execution.
The traditional failure modeling method for processing massive performance status logs of Software as a Service (SaaS) application software lacks an effective feature extraction and data processing mechanism. As a result, the model cannot fully learn the key failure-related information during training, which impairs its ability to accurately assess the fault tendency of software modules. To address this issue, a fault modeling analysis method for SaaS application software modules based on big data tendency prediction is proposed. The Hidden Markov Random Field (HMRF) model, a technique in big data analytics, is employed to observe the massive performance status logs generated during SaaS operation, from which useful information is extracted to form observation values. The maximum posterior probability estimation principle is then used to calculate the posterior probability of software module failure based on the observations generated by the HMRF model, thereby determining whether a failure occurs. Once a fault is confirmed in the SaaS application software module, a radial basis function neural network (RBFNN) is further introduced to predict the fault tendency. By training the RBFNN model, the mapping relationship between fault factors and fault occurrence is established, enabling fault prediction and early warning. Experimental results show that the proposed method successfully performs fault prediction and analysis on the test subjects. In fault judgment, the precision and recall rates reach 97.2% and 96.1%, respectively; in fault prediction, the precision and recall rates reach 96.3% and 94.1%, respectively. Moreover, the proposed method exhibits low real-time energy consumption for fault analysis, demonstrating its high efficiency and practicality in real-world applications.
Predicting software defects is a long-standing challenge in software engineering because defects discovered late in the process can be expensive and time consuming to fix. In this study, we introduce a contrastive learning approach that incorporates an inter-sample attention mechanism, inspired by transformer models, to create context-aware representations of software classes. The idea is to not only examine software metrics but also consider how software classes relate to each other within a project, allowing the model to assign weights to features dynamically based on these relationships. We evaluated our method on nine projects from three widely used benchmark datasets (PROMISE, AEEEM, and ReLink) and compared it against five baselines: two recent state-of-the-art transformer-based models designed for tabular data (FT-Transformer and SAINT), and three widely adopted tree-based classifiers (Random Forest, XGBoost, and CatBoost). Our results show that the proposed approach outperforms all five baselines across all nine projects, with consistent improvements in the F1-score across projects with varying defect ratios ranging from 13.1% to 50.5%. These findings suggest that combining contrastive learning with inter-sample attention mechanisms provides a promising method for leveraging the similarities between software classes for defect prediction, primarily relying on software metrics.
Parameter descriptions are essential for improving developers' understanding of the source code and its functionality. An effective approach for generating descriptions for each parameter individually requires appropriate contextual information, typically represented as code or abstract syntax tree (AST). Prior research lacks a systematic investigation into how different granularities of context, their combinations, and parameter characteristics affect the effectiveness of parameter description generation. This study aims to address the gap by investigating the effectiveness of different types of contextual information, function-level context, parameter-related context and the integration of semantic and structural context, in generating parameter descriptions. Additionally, we analyze the impact of parameter characteristics, such as the number of parameters and naming conventions, on the quality of generated descriptions. The study revealed several key findings for parameter description generation: (1) trained-from-scratch deep learning models perform better with parameter-related code than with full code, whereas pre-trained models show no significant difference. (2) Full AST outperforms parameter-related AST across all models. (3) Combining semantic and structural information does not generally improve performance. (4) Models perform better with fewer function parameters (1 or 2), and performance decreases as the number of parameters increases. (5) Models perform best when parameter names are single dictionary words, and pre-trained models are more effective at handling combination names. These findings provide practical guidance for selecting appropriate contextual information and designing more effective parameter description generation approaches for future research in this domain.
UML is widely adopted for modelling object-oriented software systems, including diagrams that cover the several facets of the entire development life cycle. Approaches to formal semantics of UML tend to concentrate on individual diagrams and, so far, no complete, standard, semantics is available. Here, we explore a different path and define a natural-language semantics for UML models that embody state machines and composite structure diagrams. We then integrate with the NAT2TEST strategy to provide means for an integrated framework for the validation (via simulation) and verification (via testing - QuickChick, interactive theorem proving - Rocq, and model checking - FDR) of UML models. The integration is based on a systematic process (mapping rules), and its soundness has been validated considering an independent reference formal semantics. The developed tool support uses ATL to implement the translation from UML models to natural-language requirements directly based on the proposed mapping rules. We illustrate our contributions and tool support with respect to two case studies: the classical Dijkstra's dining philosophers problem, and a distributed ring-buffer model.
Constraint satisfaction problems involving strings have been a subject of theoretical study for decades, but the recent years have seen an increased interest in the development of practical solving methods. This interest in solving string constraints led to the development of various techniques and solvers, often accompanied by specific benchmark sets. As a result, there is now a substantial corpus of publicly available, yet largely unclassified, such benchmarks. In this context, we present SMTQuERY, a framework for maintaining and analyzing benchmarks for SMT string problems. SMTQuERY enables the execution of user-defined queries to extract domain-specific information from these benchmarks, facilitating a deeper analysis of the underlying problems. We demonstrate its utility by analyzing over 100,000 benchmarks and training an algorithm selection model to match benchmarks with suitable solvers.
