Sequence diagrams are a popular technique for describing interactions between software entities. However, because the OMG group's UML standard is not based on a rigorous mathematical structure, it is impossible to deduce a single interpretation for the notation's semantics, nor to understand precisely how its different fragments interact. While there are a lot of suggested semantics in the literature, they are too mathematically demanding for the majority of software engineers, and often incomplete, especially in dealing with the semantics of lifeline creation and deletion. In this work we describe a simple semantics based on the theory of regular languages, a mathematical theory that is a standard part of the curriculum in every computer science undergraduate degree and covers all the major compositional fragments, and the creation and deletion of lifelines.

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.

Cyber-physical systems (CPSs) are distributed assemblages of computing, communicating, and physical components that sense their environment, algorithmically assess the incoming information, and affect their physical environment. Thus, they share a common structure with other complex adaptive systems, and therefore share both the possible benefits and the probable harmful effects of emergent phenomena. Emergence is an often unexpected pattern that arises from the interactions among the individual system components and the environment. In this paper we focus on three major problems concerning emergence in the context of CPSs: how to successfully exploit emergence, how to avoid its detrimental effects in a single CPS, and how to avoid harmful emergence that arises due to unexpected interaction among several independently developed CPSs that are operating in the same environment. We review the state of the research with regard to these problems and outline several approaches that could be used to address them.

Large and complicated UML models are not useful, because they are difficult to understand. This problem can be solved by using several diagrams of the same system at different levels of abstraction. Unfortunately, UML does not define an explicit set of rules for ensuring that diagrams at different levels of abstraction are consistent. We define such a set of rules, that we call diagram refinement. Diagram refinement is intuitive, and applicable to several kinds of UML diagrams (mostly to structural diagrams but also to use case diagrams), yet it rests on a solid mathematical basis-the theory of graph homomorphisms. We illustrate its usefulness with a series of examples.

A semantics-preserving transformation by Komondoor and Horwitz has been shown to be most effective in the elimination of type-3 clones. The two original algorithms for realizing this transformation, however, are not as efficient as the related (slice-based) transformations. We present an asymptotically-faster algorithm that implements the same transformation via bidirectional reachability on a program dependence graph, and we prove its equivalence to the original formulation.

Abstract Decomposing a system into subsystems is essential to the design of large software systems. Traditionally, it is performed intuitively without rigorously analyzing the system model. This makes it difficult to check the decomposition correctness, and risks creating subsystems that are either too tightly coupled or not cohesive enough. An aggravating factor is that traditionally classes are the atomic design units. In many cases, however, the same classes play a role in more than one subsystem, and partitioning them unbroken among the subsystems may increase coupling and reduce cohesion. We present an analytical approach that enables reasoning about early exploration of decomposition alternatives. In addition, we describe a visual notation for diagramming the composition of subsystems, and an automatic technique for suggesting good decompositions. A key to our approach is that individual relations, not classes, are the atomic design units. We illustrate the approach with examples and demonstrate its effectiveness on a commercial system. This paper is an extended version of previous work.

Reactive programs often control safety-critical systems, thus it is essential to verify their safety requirements. ESTEREL is a synchronous programming language for developing control-dominated reactive systems, and XEVE is a verification environment that analyzes circuit descriptions generated from ESTEREL programs. However, a circuit generated by the ESTEREL compiler from non-pure ESTEREL program often displays behaviors which may violate safety properties even when the source program does not. We introduce an automatic abstraction process for ESTEREL programs developed to tackle this problem. When the process is applied to a program augmented with observers to monitor the program's behavior, it results in a pure program that preserves the behavior of the source program, replacing value-carrying objects with pure signals. We have built a prototype tool that implements the abstraction and used it to purify control programs and robotic systems.

CRC cards are an informal approach to object oriented modeling, used to represent the responsibilities of classes and the interaction between the classes. They are created through white-box scenarios that model the behavior of the system. Sequence diagrams are the most popular UML artifact for scenarios modeling. Though closely related, the CRC cards methodology is not supported by most UML modeling tools, and tools that support CRC cards do not support UML diagrams. This paper presents EasyCRC, a tool that combines sequence diagrams with CRC cards, originally written to teach the object-oriented paradigm.

The construction and maintenance of large and complex software systems depend on the existence of global principles describing the structure and the interaction among its various components. Due to their critical nature, such principles have to be explicitly formulated and strictly verified and enforced throughout the lifetime of the software product. Aspect Oriented Software Development (AOSD) provides necessary tools for the formulation of such principles as aspects--called here structural aspects, and for their compile-time verification and dynamic enforcement. This enforcement, however, becomes problematic when aspects are also used as a vehicle for programming the components themselves, due to aspect interference. In this paper we show how the aspects embedded in system's components--called here programming aspects--can interact unfavourably with other components thus invalidating the role of the structural aspects. We present a number of methods that address this problem, and we introduce a DirectedPairWiseWeaver tool we have developed in order to prevent this interference.

Design by contract is a practical methodology for evolving code together with its specification. The contract has important methodological implications on the design of the program. In addition, tools that instrument the code to check for contract violations help the development process by catching errors close to their sources. This is complicated by several factors, such as the need to collect preconditions from supertypes. There are two issues involved in the implementation of such a tool: the correct enforcement of the theoretical principles, and the instrumentation of the code. Most previous tools tackle both issues, but have subtle failures in one or the other. This paper describes Jose, a tool for design by contract in Java, which uses AspectJ, an aspect-oriented extension of Java, to instrument the program. This allows us to leverage the expertise of the AspectJ developers in instrumenting Java programs, and concentrate on the correct implementation of the design by-contract principles. This approach has the added benefit that it can be generalized to other object-oriented languages that have aspect-oriented extensions. We describe the design decisions made in the implementation of Jose, and the features of AspectJ that helped or hindered this implementation

UML provides several kinds of diagrams to model the behavior and structure of a system under development. A consistency problem may arise due to the fact that some aspects of the model may be described by more than one diagram. Hence, it is important that the consistency of the system description should be checked before implementing it. This paper describes an algorithmic approach to a consistency check between UML sequence and state diagrams. The algorithm we provide also handles complex state diagrams, e.g. diagrams that include forks, joins, and concurrent composite states. We describe the algorithm in detail, and elaborate on the design decisions made while developing the algorithm. We have implemented BVUML, a tool that assists in automating the validation process.

The OBSERV methodology for software development is based on rapid construction of an executable specification, or prototype, of a systems, which may be examined and modified repeatedly to achieve the desired functionality. The objectives of OBSERV also include facilitating a smooth transition to a target system, and providing means for reusing specification, design, and code of systems and subsystems. We are particularly interested in handling embedded systems, which are likely to have concurrency and have some real-time requirements. The OBSERV prototyping language combines several paradigms to express the behavior of a system. The object-oriented approach provides the basic mechanism for building a system from a collection of objects, with well-defined interfaces between them. We use finite-state machines to model the behavior of individual objects. At a lower level, activities that occur within objects, either upon entry to a state or in transition between thus allowing a nonprocedural description. The environment provided to a prototype builder is as important as the language. We have made an attempt to provide flexible tools for executing or simulating the prototype being built, as well as for browsing and static checking. The first implementation of the tools was window based but not graphic. A graphic front end, name CRUISE, was developed afterwards. A simulation sequence focuses on a single object, which can be as complex as necessary, possibly the entire system, and expects all the interactions between it and the outside world to be achieved by communication between the simulator and the user. The simulator allows the user to easily switch back and forth from one object to another, simulating each object in isolation. To enable testing the behavior of a prototype in a realistic environment, it is possible to construct objects that imitate the environment objects. We also allow simulation of systems with missing pieces, by calling upon the user to simulate any such missing piece by himself.

A system for user-interface specification is presented. The authors use OBSERV, an innovative methodology for prototyping reactive systems which combines three paradigms: the object-oriented approach, state transition diagrams, and logic programming. This combination is very useful for specifying user interfaces, which can be viewed as reactive systems. The usability of OBSERV is enhanced by a user-interface, CRUISE, that provides graphic editing capabilities.>