Merge conflicts have become a critical bottleneck in version control systems, significantly hindering development efficiency, and typically rely on manual, time-consuming processing. In recent years, learning-based methods have transformed the solution of merge conflicts from a classification problem to a generative task, directly generating post-conflict code by sequentially generating code tokens. Although this approach overcomes certain limitations of classification methods (e.g., the inability to introduce new code tokens), relying solely on the conflicting code for direct generation makes it difficult to effectively resolve complex conflicts that involve non-trivial semantics or distributed changes. To address this, this paper proposes MergeCoT, a reasoning-guided merge generation framework based on Chain-of-Thought (CoT) prompting with Large Language Models (LLMs). Specifically, we design a simple Domain-Specific Language (DSL), introducing an Edit Script (ES) to structurally represent conflict information and guide the reasoning process. We then automatically construct a training dataset with explicit reasoning traces using a two-stage data generation pipeline that leverages both DSL and ES representations. Experimental results on this dataset show that MergeCoT significantly outperforms the current state-of-the-art (SOTA) techniques in terms of precision and accuracy. The accuracy on Java reached 73.8% (an absolute improvement of 6.1%). Furthermore, experiments on various programming languages demonstrate MergeCoT’s superior multilingual versatility and cross-language generalisation ability. Additional ablation studies validate the critical role of the ES and CoT mechanisms in enhancing performance.

As software systems grow in complexity, Model-Driven Development demands precise and scalable verification techniques. UML enables multi-view modeling, yet its semiformal semantics frequently lead to inconsistencies across diagrams. This paper presents a consistency verification approach for class and sequence diagrams using the Alloy modeling language. We systematically transform UML models into Alloy logic through a modular abstraction strategy and a set of formal consistency rules spanning structural, behavioral, and cross-view semantics. The Alloy Analyzer then performs constraint solving, automatically detects violations, and generates counterexamples for debugging. Evaluated in a case study, the method demonstrates effective inconsistency detection, comprehensive rule coverage, and reliable validation of interaction logic. Results confirm that the approach enables automated, fine-grained consistency checking and integrates smoothly into formal verification workflows.

Requirements analysis is a crucial phase in software development. Manual conversion of natural language to models is error-prone and inefficient. Large Language Models (LLMs) offer a promising approach for automating requirement modelling, but there is a gap between their generated results and the needs of real applications. We introduce an interactive and iterative optimisation framework (GCSS) comprising generation, comparison, selection, and supplementation components. GCSS employs a staged strategy to guide LLMs in model generation. By continuously generating, comparing, and incorporating user decisions, GCSS explores and integrates various modelling options. This leads to an optimal solution. Automatically generated feedback is used as supplementary information to guide the next generation, enabling continuous optimisation of outcomes. We evaluated GCSS on different cases, and the experiments show that the models it generates align with expectations, while reducing workload.

Federated Learning (FL) is a distributed machine learning framework that enables model training while preserving user data privacy. However, the heterogeneity of the distributed clients regarding, e.g., system performance, data quality and network conditions, makes client selection a critical factor in optimising the performance of FL. We propose a fair and efficient client selection algorithm (FeFL) based on dynamic contribution evaluation. The algorithm optimises the client selection process by evaluating data quality, device performance, and their impact on model accuracy. FeFL introduces a dynamic contribution evaluation model that adjusts the weights of various contributions based on different training stages, enabling the selection of the most contributing clients at minimal cost. Additionally, the waiting factor introduced in FeFL ensures fairness in client selection. Experimental results on real-world datasets demonstrate that the algorithm significantly improves model accuracy and convergence speed under both Independent and Identically Distributed (IID) and non-Independent and Identically Distributed (non-IID) conditions while exhibiting greater robustness and stability in managing data heterogeneity.

Microservice architecture is favoured for its significant scalability, independent evolution, and advantages in performance elasticity. Partitioning a monolith into microservices has become a pivotal issue in software architecture refactoring. Concurrently, assessing the quality of such partitioning also presents a significant challenge. To address this problem, we propose a solution that (1) proposes a method for extracting and representing the multi-source features such as semantics, functionality, and performance of monolithic systems; (2) designs a deep fusion graph clustering model for partitioning a monolith into microservices intelligently; and (3) establishes a comprehensive set of assessment metrics to quantify the quality of the partitioning suggestion. We conducted experiments and analyses on five benchmark projects. By comparing our approach with six other methods, we have demonstrated the advantages of our methodology. Furthermore, ablating different modules has validated the effectiveness of our proposed monolith features analysis and deep fusion graph clustering model.

Tactical Data Link (TDL) is a complex, specialised system that supports the construction of communication applications. To navigate its complexity, model-based system engineering (MBSE), especially Unified Modeling Language (UML)-based modelling, has emerged as the leading approach in developing TDL-specific systems. However, TDL domain experts often find UML modelling notably challenging. That significantly hinders their full engagement in TDL engineering. To bridge this gap, we introduce DSL-MoLab, a tailored framework of DSL-enabled model-based development toolkit that empowers TDL domain experts to engage with the MBSE process of TDL-specific systems straightforwardly. DSL-MoLab encompasses: a domain-specific language (DSL), TDL-DSL, that incorporates TDL-specific concepts and notations fully understood by TDL domain experts; a TDL-DSL Editor that offers both graphical and command-line interfaces for interactive modelling; a UML2DSL Translator and a DSL2UML Translator that jointly facilitate bidirectional translation between UML and DSL models; and a TDL-Code Generator that converts UML models into executable programs leveraging ANTLR for the process. Additionally, DSL-MoLab utilises WebAssembly to support lightweight service deployment, allowing for running on various OS architectures. Applying this framework to a case study within Link 16 demonstrates its effectiveness in enabling TDL domain experts to significantly contribute to engineering TDL systems straightforwardly.

Service models and modelling are vital in monolith-to-microservice architecture (MSA) migration of legacy systems. Prior work focuses on service identification, whereas few efforts have been investigating microservice models and modelling. It remains an immature field of Model-Driven Development (MDD) of MSA due to it lack modelling methods and tools for monolith-to-MSA migration. We present Log2MS, an MDD framework for automated transforming legacy monolithic architecture into MSA using execution logs only. We define microservice and microservice sequence diagrams to support monolith-to-MSA structural and behavioural modelling; we present a source-code free monolith-to-MSA approach and a prototypical tool which support automatically microservices identification and MSA models generation; we developed a graphical editor to represent the generated MSA models for further interactively modelling. Log2MS is evaluated being of applicability, robustness, and effectiveness by comparative experiments with 2 representative approaches and applying to 4 projects.

Software trustworthiness is a composite reflection of software quality and dependability attributes that are defined in industrial standards (e.g., ISO 25010), indicating a software system is constructed and operated as expected. Trustworthiness evaluation has become increasingly vital for software production and its permission being used in industry. However, trustworthiness evaluation is challenging due to the absence of comprehensive models, systematic methods, and efficient tools. We present iTrustEval a framework for software trustworthiness evaluation with an intelligent analytic hierarchy process (AHP)based method. In iTrustEval an extensible trustworthiness model enabling on-demand integration with industrial trustworthy standards (such as ISO 25010 and Automotive SPICE in the current model) is proposed; an AHP based method is designed for the bottom-up measuring data fusion (where a hybrid missing-value recommendation engine is developed using both temporal-attenuation-mechanism based history data recommendation and matrix factorisation-based recommender system); and a prototypical tool has been developed. The applicability of iTrustEval is validated through a case study, and the results show it is sound in efficiency and effectiveness.

Since microservice has merged as a promising architectural style with advantages in maintainability, scalability, evolvability, etc., increasing companies choose to restructure their legacy monolithic software systems as the microservice architecture. However, it is quite a challenge to properly partitioning the systems into suitable parts as microservices. Most approaches perform microservices identification from a function-splitting perspective and with sufficient legacy software artifacts. That may be not realistic in industrial practices and possibly results in generating unexpected microservices. To address this, we proposed an automated microservice identification (AMI) approach that extracts microservices from the execution and performance logs without providing documentation, models or source codes, while taking both functional and non-functional metrics into considerations. Our work firstly collects logs from the executable legacy system. Then, controller objects (COs) are identified as the key objects to converge strongly related subordinate objects (SOs). Subsequently, the relation between each pair of CO and SO is evaluated by a relation matrix from both the functional and non-functional perspective. We ultimately cluster classes(objects) into the microservices by optimizing the multi-objective of high-cohesion-low-coupling and load balance. The usefulness of the proposed approach is illustrated by applying to a case study.

Cyber-physical systems (CPSs) have emerged as a potential enabling technology to handle the challenges in social and economic sustainable development. Since it was proposed in 2006, intensive research has been conducted, showing that the construction of a CPS is a hard and complex engineering process due to the nature of integrating a large number of heterogeneous subsystems. Among other approaches to dealing with the complex design issues, model-driven design of CPSs has shown its advantages. In this review paper, we present a survey of research on model-driven development of CPSs. We are concerned mainly with the widely used methods, techniques, and tools, and discuss how these are applied to CPSs. We also present comparative analyses on the surveyed techniques and tools from various perspectives, including their modeling languages, functionalities, and the challenges which they address in CPS design. With our understanding of the surveyed methods, we believe that model-driven approaches are an inevitable choice in building CPSs and further research effort is needed in the development of model-driven theories, techniques, and tools. We also argue that a unified modeling platform is needed. Such a platform would benefit research in the academic community and practical development in industry, and improve the collaboration between these two communities.