Abstract OpenHarmony LiteOS-M, a preemptive operating system (OS) kernel for the Internet of Things (IoT), is widely deployed in safety-critical domains, such as aerospace and transportation. As a rigorous method to assure software safety, formal verification has been applied to OS kernels in industry. However, entirely verified kernels with large codebases are rare, since such verification is typically performed within interactive theorem provers, requiring substantial human effort. In this paper, we present the functional correctness verification of LiteOS-M. First, to improve verification efficiency, we design a formal verification platform, Smart Verifier. The platform employs an annotation-based verifier as the front end, while the back end integrates Z3 and Rocq, combining automatic and interactive theorem proving techniques. Second, we tailor two verification methods, expressing program refinement as standard Hoare logic triples and modeling concurrency through state transition systems, to utilize the platform for verifying LiteOS-M. Our verified LiteOS-M kernel consists of 17,000 lines of C. During the code review and verification, we find a total of 17 bugs, all confirmed and fixed by developers.

Event reasoning is to reason with events and certain inter-event relations. These cutting-edge techniques possess crucial and fundamental capabilities that underlie various applications. Large language models (LLMs) have made advances in event reasoning owing to their wealth of training. However, the LLMs commonly used today still do not consistently demonstrate proficiency in managing event reasoning as humans. This discrepancy arises from not explicitly modeling events and their relations and insufficient knowledge of event relations. In addition, the different reasoning paradigms of the LLMs are trained in an imbalanced way. In this paper, we propose WIZARDEVENT, to synthesize data from the unlabeled corpus with the proposed hybrid event-aware instruction tuning. Specifically, we first represent the events and their relation in a novel structure and then extract the knowledge from the raw text. Second, we introduce hybrid event reasoning paradigms with four reasoning formats. Lastly, we wrap our constructed WIZARDEVENT with the paradigms to create the instruction tuning dataset. We fine-tune the model with this enriched dataset, significantly improving the event reasoning. The performance of WIZARDEVENT is rigorously evaluated through extensive experiments. The results demonstrate that WIZARDEVENT substantially outperforms baselines, indicating the effectiveness of our approach.

Knowledge graphs (KGs) play a key role in promoting various multimedia and AI applications. However, with the explosive growth of multi-modal information, traditional knowledge graph completion (KGC) models cannot be directly applied. This has attracted a large number of researchers to study multi-modal knowledge graph completion (MMKGC). Since MMKG extends KG to the visual and textual domains, MMKGC faces two main challenges: (1) how to deal with the fine-grained modality information interaction and awareness; (2) how to ensure the dominant role of graph structure in multi-modal knowledge fusion and deal with the noise generated by other modalities during modality fusion. To address these challenges, this paper proposes a novel MMKGC model named TSAM, which integrates fine-grained modality interaction and dominant graph structure to form a high-performance MMKGC framework. Specifically, to solve the challenges, TSAM proposes the Fine-grained Modality Awareness Fusion method (FgMAF), which uses pre-trained language models better to capture fine-grained semantic information interaction of different modalities and employs an attention mechanism to achieve fine-grained modality awareness and fusion. Additionally, TSAM presents the Structure-aware Contrastive Learning method (SaCL), which utilizes two contrastive learning approaches to align other modalities more closely with the structured modality. Extensive experiments show the proposed TSAM model significantly outperforms existing MMKGC models on widely used multi-modal datasets. The code is available athttps://github.com/2391134843/TSAM.

Event reasoning is a fundamental ability that underlies many applications. It requires event schema knowledge to perform global reasoning and needs to deal with the diversity of the inter-event relations and the reasoning paradigms. The extent to which LLMs excel in event reasoning across various relations and reasoning paradigms has not been thoroughly investigated. Additionally, it is still unclear whether LLMs utilize event knowledge in the same way humans do. To mitigate this disparity, we comprehensively evaluate the abilities of event reasoning of LLMs on different relations, paradigms, and levels of abstraction. We introduce a novel benchmark EV2 for EValuation of EVent reasoning. EV2 consists of two levels of evaluation on schema and instance and is comprehensive in relations and reasoning paradigms. We conduct extensive experiments on EV2. We find that 1) LLMs have abilities to accomplish event reasoning but their performances are far from satisfactory. 2) There are imbalances of event reasoning abilities on different relations and paradigms. 3) LLMs have event schema knowledge, however, they're not aligned with humans on how to utilize the knowledge. Based on these findings, we guide the LLMs in utilizing the event schema knowledge as memory leading to improvements in event reasoning.

Large language models (LLMs) have demonstrated significant advancements in code generation, yet they still face challenges when tackling tasks that extend beyond their basic capabilities. Recently, the concept of self-debugging has been proposed as a way to enhance code generation performance by leveraging execution feedback from tests. However, the availability of high-quality tests in real-world scenarios is often limited. In this context, self-debugging with self-generated tests emerges as a promising solution, though its limitations and practical potential have not been fully explored. To address this gap, we investigate the efficacy of self-debugging in code generation tasks. We propose and analyze two distinct paradigms for the self-debugging process: post-execution and in-execution self-debugging. Our findings reveal that post-execution self-debugging struggles with the test bias introduced by self-generated tests, which can lead to misleading feedback. In contrast, in-execution self-debugging enables LLMs to mitigate this bias and leverage intermediate states during program execution. By focusing on runtime information rather than relying solely on potentially flawed self-generated tests, this approach demonstrates significant promise for improving the robustness and accuracy of LLMs in code generation tasks.

Although existing automated merging tools have made efforts in merging displayed text and syntactic conflicts, the deep logical and semantic conflicts that do not cause compilation errors still require human review to fully resolve. In order to make the merged results more reliable and reduce the workload of human review, we propose DEEPGRAPHMERGE, a reliable merge conflict resolution system that specifically detects and resolves deep logical and semantic conflicts in collaborative development. Our method combines hierarchical directed graph neural networks (HD-GNN) with static analysis to identify and reconcile complex, deep semantic and logical conflicts across files. The key innovation lies in our hierarchical dependency graph, which explicitly explores the underlying program logic, enabling precise detection of deep semantic and logical conflicts. Experimental results across four languages (Java, C#, JavaScript, TypeScript) demonstrate superior performance: 91.2% accuracy in resolving challenging semantic and logical conflicts. The method’s ability to understand and harmonize deep semantic and logical differences represents a significant advance over current merge technologies.

Recent advances in self-supervised learning for Vision Transformers (ViTs) have fueled breakthroughs in remote sensing (RS) foundation models. However, the quadratic complexity of self-attention poses a significant barrier to scalability, particularly for large models and high-resolution images. While the linear-complexity Mamba architecture offers a promising alternative, existing RS applications of Mamba remain limited to supervised tasks on small, domain-specific datasets. To address these challenges, we propose RoMA, a framework that enables scalable self-supervised pretraining of Mamba-based RS foundation models using large-scale, diverse, unlabeled data. RoMA enhances scalability for high-resolution images through a tailored auto-regressive learning strategy, incorporating two key innovations: 1) a rotation-aware pretraining mechanism combining adaptive cropping with angular embeddings to handle sparsely distributed objects with arbitrary orientations, and 2) multi-scale token prediction objectives that address the extreme variations in object scales inherent to RS imagery. Systematic empirical studies validate that Mamba adheres to RS data and parameter scaling laws, with performance scaling reliably as model and data size increase. Furthermore, experiments across scene classification, object detection, and semantic segmentation tasks demonstrate that RoMA-pretrained Mamba models consistently outperform ViT-based counterparts in both accuracy and computational efficiency. The source code and pretrained models have be released at https://github.com/MiliLab/RoMA.

As the application of knowledge graphs becomes increasingly widespread, the issue of knowledge graph incompleteness has garnered significant attention. As a classical type of non-euclidean spatial data, knowledge graphs possess various complex structural types. However, most current knowledge graph completion models are developed within a single space, which makes it challenging to capture the inherent knowledge information embedded in the entire knowledge graph. This limitation hinders the representation learning capability of the models. To address this issue, this paper focuses on how to better extend the representation learning from a single space to Riemannian manifolds, which are capable of representing more complex structures. We propose a new knowledge graph completion model called MRME-KGC, based on multi-view Riemannian Manifolds fusion to achieve this. Specifically, MRME-KGC simultaneously considers the fusion of four views: two hyperbolic Riemannian spaces with negative curvature, a Euclidean Riemannian space with zero curvature, and a spherical Riemannian space with positive curvature to enhance knowledge graph modeling. Additionally, this paper proposes a contrastive learning method for Riemannian spaces to mitigate the noise and representation issues arising from Multi-view Riemannian Manifolds Fusion. This paper presents extensive experiments on MRME-KGC across multiple datasets. The results consistently demonstrate that MRME-KGC significantly outperforms current state-of-the-art models, achieving highly competitive performance even with low-dimensional embeddings.

Framework-based multilingual software development (MLSD) is becoming prevalent in software engineering practice. Despite the advantages, framework-based MLSD also leads to reduced understandability and changeability of multilingual software, due to the introduced cross-language links (XLLs). To help alleviate this problem, there are existing practice and research crafting rules to specify and detect XLLs, but only focusing on specific frameworks. With the intention of coping with the diversity of XLL conventions across different multi-lingual frameworks, this paper proposes Focused, an extensible approach to framework-oriented cross-language link specification and detection. The basic idea is to decouple the two activities of XLL specification and detection as much as possible by mediating between them with a set of DSL-enabled XLL rules, making Focused configurable to different multilingual frameworks. We evaluated Focused on 3 widely-used multilingual frameworks and 15 high-starred open-source projects using these frameworks, showing the expressiveness, effectiveness, and efficiency of Focused.

In collaborative software development, developers generally make code changes and commit the changes to the repositories. Among others, "making small, single-purpose commits" is considered the best practice for making commits, allowing the team to quickly understand the code changes. Rather than following best practices, developers often make tangled commits, which wrap code changes that implement different purposes. Such commits make it difficult for other developers to understand the code changes when conducting subsequent development. Early works on untangling code changes rely on human-specified heuristic rules or features, do not consider context, and are labor intensive. Recent works model the local context of code changes as a graph at the statement level, with statements as nodes and code dependencies as edges, and then cluster the changed statements. However, recent works ignore the hidden dependencies in the global context, e.g. a pair of tangled code changes may have no code dependency, and a pair of untangled code changes may have obvious code dependency. To solve this problem, we focus on detecting hidden dependencies among code changes. We model the global context of code changes as graphs at finer-grained, hierarchical levels, i.e., at both entity and statement levels. Then we propose a Heterogeneous Directed Graph Neural Network (HD-GNN) to detect hidden dependencies among code changes by aggregating the global context in both connected or disconnected entity-level subgraphs that intersected with the code changes. Evaluation of common C # and Java datasets with 1,612 and 14k tangled commits and manually validated datasets (MVD) with 600 commits shows that HD-GNN achieves an average enhancement of effectiveness of 25% and 19.2% compared to existing approaches and far superior to existing approaches in MVD, without sacrificing time efficiency.

The performance of repository-level code completion depends upon the effective leverage of both general and repository-specific knowledge. Despite the impressive capability of code LLMs in general code completion tasks, they often exhibit less satisfactory performance on repository-level completion due to the lack of repository-specific knowledge in these LLMs. To address this problem, we propose GraphCoder, a retrieval-augmented code completion framework that leverages LLMs' general code knowledge and the repository-specific knowledge via a graph-based retrieval-generation process. In particular, GraphCoder captures the context of completion target more accurately through code context graph (CCG) that consists of control-flow, data- and control-dependence between code statements, a more structured way to capture the completion target context than the sequence-based context used in existing retrieval-augmented approaches; based on CCG, GraphCoder further employs a coarse-to-fine retrieval process to locate context-similar code snippets with the completion target from the current repository. Experimental results demonstrate both the effectiveness and efficiency of GraphCoder: Compared to baseline retrieval-augmented methods, GraphCoder achieves higher exact match (EM) on average, with increases of +6.06 in code match and +6.23 in identifier match, while using less time and space.

Heterogeneous graphs provide a universal data structure for representing various kinds of structured data in numerous domains. The graph alignment problem aims to find the correspondences of vertices in different graphs, playing a fundamental role in many downstream tasks of heterogeneous graph mining. In recent years, many graph alignment methods have been proposed, ranging from classical optimization methods , spectral methods , to embedding learning based-methods . Due to the problem's complexity, the result found by most existing methods is either a heuristic solution or a critical point in the solution space. In this paper, we propose GABoost, a graph alignment boosting algorithm that takes as input an initial alignment between two heterogeneous graphs and outputs a boosted alignment via an iterative local-optimum-escape process. One of the distinctive features of GABoost is that it can be sequentially composed with any graph alignment methods to improve the output of upstream methods. To examine the effectiveness of GABoost, we select 7 upstream methods of graph alignment as well as 6 real-world datasets, and quantitatively investigate the degree to which GABoost boosts these methods. The results show that GABoost improves the alignment accuracy of the 7 upstream methods by 25.25% on average with acceptable time overhead.

Zhengwei Tao, Zhi Jin, Haiyan Zhao, Chengfeng Dou, Yongqiang Zhao, Tao Shen, Chongyang Tao. Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2023.

Shape formation mechanism plays an essential role in many natural processes, involving the formation and evolution of living or non-living structures, and shows potential applications in many emerging domains. In existing research and practice, there still lacks a shape formation mechanism that manifestsefficiency,scalability, andstabilityat the same time. Inspired byphototaxisobserved in nature, we propose a self-organized approach for the massive formation of connected shapes in grid environments. The key component of this approach is anartificial light fieldsuperimposed on a grid environment, which is determined by the positions of all agents and at the same time drives all agents to change their positions, forming a dynamic mutual feedback process. To evaluate the effectiveness of this approach, we conduct a set of simulations, involving 156 shapes from 16 categories, comparing with four baseline methods. The results show that: (1) our approach outperforms the three semi-/decentralized non-optimal baselines inefficiency,scalability, andstability; (2) compared to the centralized optimal baseline, our approach exhibits considerable decreases in theabsolute completion timeon diverse shape formation tasks, indicating a better efficiency and scalability of our approach.Note to Practitioners—In nature, shape formation phenomena emerge from collective behaviors of swarms based on chemical or physical signals. These natural phenomena provide valuable insights to build large-scale multi-agent collaboration systems using software-defined digital signals. This work proposes a phototaxis-inspired computational approach for shape formation that enables a massive swarm of agents to form arbitrary connected shapes in grid environments based on a digital signal called artificial light field. The significance of this work is twofold: 1. it could contribute to a deep understanding of shape formation mechanisms; 2. it would motivate new research on advanced multi-agent algorithms, massive collaboration mechanisms, and artificial collective intelligence systems and facilitate their practical applications. Specifically, the shape formation mechanism has promising applications, including smart warehouses, autonomous cooperation of UAVs, and intelligent transportation systems. A possible realistic application scenario of our method in intelligent transportation systems is bike sharing systems, in which the designated parking areas for shared bicycles near the work area are often overcrowded and difficult to park in during the morning peak period, so dynamic parking route guidance for users is required. Our method can directly apply to this scenario by utilizing the light field to represent the parking state of nearby bicycles and guiding the moving direction of each user.

Reinforcement learning is a powerful methodology that enables self-adaptive systems to relearn and update their adaptation policy when dealing with unforeseen changes. To update the policy more efficiently, several knowledge reuse approaches have been proposed to speed up relearning. However, the current studies treat and reuse the knowledge integrally, which may result in increased relearning costs if the reused knowledge is inappropriate in the changed situation. Generally, some localized pieces of the knowledge are still appropriate for reuse if they are not related to the changes, while some pieces may become inappropriate for reuse if they are affected by the changes. This paper proposes a goal-oriented curriculum evolution method to realize finer-grained knowledge reuse, combining goal-oriented modeling and curriculum learning. The method is twofold: (1) at design time, we apply goal-oriented modeling to design a curriculum in which an RL problem is decomposed into sub-problems, so that knowledge can be decomposed into several pieces of localized knowledge for sub-problems, and (2) at runtime, we evolve the curriculum to reflect changes (i.e., update the sub-problems related to the changes), so that the affected pieces of knowledge can be locally updated to make them appropriate for reuse in the changed situation. The evaluation based on a cleaning robot shows that the relearning time was shortened, demonstrating the effectiveness of our method.

Autonomous Unmanned Systems (AUSs) emerge to replace human operators for better efficiency and effectiveness, especially in harsh and dangerous environments which frequently imply uncertainty. Safety has become one of the top concerns for AUS designs. To address AUS safety concerns systematically, we aim to establish a comprehensive taxonomy of AUS safety and provide a safety-by-design framework for architecting safer AUSs. We conduct a systematic literature review on 65 primary studies and analyze them from three perspectives: system and environment features, safety threats, and countermeasures. We adopt feature models to organize the survey results and establish a taxonomy for AUSs safety issues. Based on the taxonomy, we figure out a reference architecture that integrates three control loops dealing with the uncertainty of operating environments, external threats and system deviations, respectively. Our survey reveals that AUS safety is still a formative field and presents a taxonomy for AUSs safety issues and a safe-by-design framework for architecting safer AUSs.

Autonomous Driving Systems (ADSs) are complex systems that must satisfy multiple safety requirements. In particular cases, all the requirements cannot be satisfied at the same time, and the control software of the ADS must make trade-offs among their satisfaction. Usually, the trading-offs in the decision-making process are configurable; different configuration options can affect driving behaviors, satisfying or violating requirements at different degrees. Therefore, it is highly important to know whether a configuration can guarantee a safe drive or not, i.e., whether it leads to requirement violations that exceed the allowable range or not. However, there is currently no approach to systematically assess the safety of ADS configurations from the perspective of requirements violations. To bridge this gap, this paper proposes a “Hierarchical Safety Assessment” approach (HSA) that is able to quantitatively analyze the violation severity of safety requirements and distinguish safer ADS configurations based on the requirements violations comparison done in a hierarchical way by following requirements importance. We apply HSA to an industrial ADS under six traffic situations. Evaluation results show that HSA is effective in distinguishing safer configurations and provides useful feedback to ADS engineers to reconfigure the ADS in a better way.

Abstract Scene graph generation refers to the task of identifying the objects and specifically the relationships between the objects from an image. Existing scene graph generation methods generally use the bounding boxes region features of objects to identify the relationships between objects. However, we feel that the overlap region features of two objects may play an important role in fine‐grained relationship identification. In fact, some fine‐grained relationships can only be obtained from the overlap region features of two objects. Therefore, we propose the Multi‐Branch Feature Combination (MFC) module and Overlap Region Transformer (ORT) module to comprehensively obtain the visual features contained in the overlap regions of two objects. Concretely, the MFC module uses deconvolution and multi‐branch dilation convolution to obtain high‐pixels and multi‐receptive field features in the overlap regions. The ORT module uses the vision transformer to obtain the self‐attention of the overlap regions. The joint use of these two modules achieves the mutual complementation of local connectivity properties of convolution and the global connectivity properties of attention. We also design a Geometrical Center Augmented (GCA) module to obtain the relative position information of the geometric centers between two objects, to prevent the problem that only relying on the scale of the overlap region cannot accurately capture the relationship between two objects. Experiments show that our model ORGC (Overlap Region and Geometrical Center), the combination of the MFC module, the ORT module, and the GCA module, can enhance the performance of fine‐grained relation identification. On the Visual Genome dataset, our model outperforms the current state‐of‐the‐art model by 4.4% on the R@50 evaluation metric, reaching a state‐of‐the‐art result of 33.88.

Framework-based multi-lingual software is increasingly prevalent, but it also brings negative effects and extra burden on software maintenance and evolution, because of the introduced cross-language code coupling, which are usually mixed with framework-specific conventions. Researchers have proposed various approaches to code coupling detection, but there is still a lack of necessary support for cross-language coupling detection in framework-based software development. In this paper, we present a preliminary study about cross-language coupling detection in software development based on the Android application framework. We investigate the characteristics of multi-lingual changes in the top-100 starred open-source Android repositories on GitHub, and find that multi-lingual commits are non-trivial: their code changes are more scattered, and more inclined to introduce bugs than other commits. To mitigate the side-effect of multi-lingual development, we propose Grace, a Graph-based cross-language co-change suggestion approach for Android application development. Grace (a) designs a language-agnostic graph to represent code elements from different languages, and (b) employs an entity-based collaborative filtering algorithm to detect and rank candidates of cross-language code couplings, from the graph representation of the latest version as well as the historical multi-lingual commits of a repository. To evaluate the effectiveness of Grace, we apply it to the two tasks of cross-language co-change suggestion and inconsistency checking. Results show that Grace (a) can effectively suggest cross-language co-changed files and types, and (b) can also find existing and potential bugs or code smells caused by inconsistent co-changes.

Autonomous Driving Systems (ADSs) are complex systems that must satisfy multiple requirements such as safety, compliance to traffic rules, and comfortableness. However, satisfying all these requirements may not always be possible due to emerging environmental conditions. Therefore, the ADSs may have to make trade-offs among multiple requirements during the ongoing operation, resulting in one or more requirements violations. For ADS engineers, it is highly important to know which combinations of requirements violations may occur, as different combinations can expose different types of failures. However, there is currently no testing approach that can generate scenarios to expose different combinations of requirements violations. To address this issue, in this paper, we introduce the notion of requirements violation pattern to characterize a specific combination of requirements violations. Based on this notion, we propose a testing approach named EMOOD that can effectively generate test scenarios to expose as many requirements violation patterns as possible. EMOOD uses a prioritization technique to sort all possible patterns to search for, from the most to the least critical ones. Then, EMOOD iteratively includes an evolutionary many-objective optimization algorithm to find different combinations of requirements violations. In each iteration, the targeted pattern is determined by a dynamic prioritization technique to give preferences to those patterns with higher criticality and higher likelihood to occur. We apply EMOOD to an industrial ADS under two common traffic situations. Evaluation results show that EMOOD outperforms three baseline approaches in generating test scenarios by discovering more requirements violation patterns.

Code merging plays an important role in collaborative software development. However, it is often tedious and error-prone for developers to manually resolve merge conflicts, especially when there are many conflicts after merging long-lived branches or parallel versions. In this paper, we present SoManyConflicts, a language-agnostic approach to help developers resolve merge conflicts systematically, by utilizing their interrelations (e.g., dependency, similarity, etc.). SoManyConflicts employs a graph representation to model these interrelations and provides 3 major features: 1) cluster and order related conflict based on the graph connectivity; 2) suggest related conflicts of one focused conflict based on the topological sorting, 3) suggest resolution strategies for unresolved conflicts based already resolved ones. We have implemented SoManyConflicts as a Visual Studio Code extension that supports multiple languages (Java, JavaScript, and TypeScript, etc.), which is briefly introduced in the video: https://youtu.be/asWhj1KTU. The source code is publicly available at: https://github.com/Symbolk/somanyconflicts.

In collaborative software development, it is considered to be a best practice to submit code changes as a sequence of cohesive commits, each of which records the work result of a specific development activity, such as adding a new feature, bug fixing, and refactoring. However, rather than following this best practice, developers often submit a set of loosely-related changes serving for different development activities as a composite commit, due to the tedious manual work and lack of effective tool support to decompose such a tangled changeset. Composite commits often obfuscate the change history of software artifacts and bring challenges to efficient collaboration among developers. To encourage activity-oriented commits, we propose SmartCommit, a graph-partitioning-based interactive approach to tangled changeset decomposition that leverages not only the efficiency of algorithms but also the knowledge of developers. To evaluate the effectiveness of our approach, we (1) deployed SmartCommit in an international IT company, and analyzed usage data collected from a field study with 83 engineers over 9 months; and (2) conducted a controlled experiment on 3,000 synthetic composite commits from 10 diverse open-source projects. Results show that SmartCommit achieves a median accuracy between 71–84% when decomposing composite commits without developer involvement, and significantly helps developers follow the best practice of submitting activity-oriented commits with acceptable interaction effort and time cost in real collaborative software development.

Collaborative tasks require the participation of multiple agents. Each agent in collaboration needs sufficient data to make optimal decisions. However, in general, each agent can only collect and process a limited amount of data due to resource constraints. Peer-to-peer data sharing can enrich local observations, but a particular agent may not have enough resources to adequately store and process data, thus compromising group decision making. Cloud-Edge Computing (CEC) can relieve agents of these limitations by providing them with further storage and computing resources through connected cloud-like infrastructures. However, CEC-based collaborations currently face two key challenges: 1) lack of adaptability to resource restrictions in data sharing; 2) no support of offloading non-trivial tasks with complex data dependencies. This paper proposes an approach to realize adaptive data sharing and support computation offloading. Roughly speaking, the paired parameterized-structure is designed based on data flow analysis and bidirectional transformations to benefit adaptive data synchronization and offloading. And a hybrid offloading mechanism is offered for allocating computations among agents and the cloud, regarding data dependencies and restrictions. We demonstrate the feasibility and flexibility through a collaborative victim search and rescue case. Experiments show that our approach outperforms state-of-the-art methods.

Autonomous unmanned systems (AUS) emerge to take place of human operators in harsh or dangerous environments. However, such environments are typically dynamic and uncertain, causing unanticipated accidents when autonomous behaviours are no longer safe. Even though safe autonomy has been considered in the literature, little has been done to address the environmental safety requirements of AUS systematically. In this paper, we conduct a systematical literature review and set up a taxonomy of environment-centric safety requirements for AUS. We then analyse the neglected issues to suggest several new research directions towards the vision of environmental-centric safe autonomy.

In modern software development, developers rely on version control systems like Git to collaborate in the branch-based development workflow. One downside of this workflow is the conflicts occurred when merging contributions from different developers: these conflicts are tedious and error-prone to be correctly resolved, reducing the efficiency of collaboration and introducing potential bugs. The situation becomes even worse, with the popularity of refactorings in software development and evolution, because current merging tools (usually based on the text or tree structures of source code) are unaware of refactorings. In this paper, we present IntelliMerge, a graph-based refactoring-aware merging algorithm for Java programs. We explicitly enhance this algorithm's ability in detecting and resolving refactoring-related conflicts. Through the evaluation on 1,070 merge scenarios from 10 popular open-source Java projects, we show that IntelliMerge reduces the number of merge conflicts by 58.90% comparing with GitMerge (the prevalent unstructured merging tool) and 11.84% comparing with jFSTMerge (the state-of-the-art semi-structured merging tool) without sacrificing the auto-merging precision (88.48%) and recall (90.22%). Besides, the evaluation of performance shows that IntelliMerge takes 539 milliseconds to process one merge scenario on the median, which indicates its feasibility in real-world applications.

Goal-oriented adaptation provides a powerful mechanism to develop self-adaptive systems, enabling systems to keep satisfying user goals in a dynamically changing environment. The goal-oriented approach normally reduces the adaptation planning as a global optimization process and leaves the system the task of determining the actions required to achieve the goals. However, the high computation cost of global optimization prevents a self-adaptive system from quickly adjusting itself to the dynamically changing environment at runtime, which is intolerable since efficiency of planning is of utmost importance in most self-adaptive systems. On the other hand, rule-based adaptation has the advantage of efficient planning process since it predefines the adaptation logic by rules instead of leaving the system the task of reasoning. To combine the advantages of both approaches, we propose a novel adaptation framework that can integrate goal model into rule-based adaptation to make user goals to be better satisfied efficiently. We have applied the framework to design a self-adaptive e-commerce website. Our experimental results show that the proposed framework outperforms both the traditional goal-oriented approach and the traditional rule-based approach in terms of adaptation efficiency and effectiveness.

The conceptual model captures the key concepts in specific problem domains, as well as the important relationships between them. The quality of the conceptual model plays an important role for the success of software development. AAs restricted by personal knowledge and experience, a single modeler usually lacks of capability to build a high-quality conceptual model, especially when the problem domain has a high complexity. The large number of modelers online could help to solve this problem. However, the crowd modelers are temporal and topographical distributed and lack of interaction, which makes it hard for them modeling collaboratively. To address this problem, we developed a tool based on the stigmergy mechanism, which provides an indirect collaboration for online modelers. In this paper, we firstly introduce the architecture of our tool. Our tool helps to make up collaboration for those distributed online crowd through a merge-feedback process. Secondly, we introduce our entropy-based merging approach which is used to merge the models generated by different modelers. Two experiments are conducted to evaluate the feasibility of the merging approach and the stigmergy-based modeling tool.

The conceptual model in software development captures the key concepts in specific problem domains, as well as the important relationships between them. The quality of the conceptual model plays an important role for the success of requirements engineering and software development. Generally, the quality of the conceptual model is restricted by modelers' personal knowledge and experience, and a single modeler usually possesses parts of the information that should be captured in a high-quality conceptual model, especially when the problem domain has a high complexity. To address this problem, we developed a tool named SCCMT, which provides an approach to modeling the conceptual model collaboratively with a large number of people, especially an online crowd. The main characteristic of this tool is twofold. (1) An indirect interaction mechanism is proposed to solve the communication problem among the temporal and topographical distributed online modelers. (2) A merge-feedback process is provided to inspire any single modeler in the crowd to improve her/his model based on the current modeling result of the crowd.

Crowdsourcing is used to obtain needed ideas and content by soliciting data from a large group of people, especially from an online community. However, the data generated by a group of people is duplicated. As to learn the crowd intention based on the crowd data, we need to do some entity resolution works. Previous works focus on data matching and merging, but remain far from perfect in crowdsourcing area. In our study, we propose a generic way in measuring and representing the crowd intention based on the crowd data. The main contribution of our study is twofold: 1. We propose a graph structure that represents the crowd intention. 2. We propose an entropy-based measurement that evaluates the diversity of the crowd intention.

Internetware denotes a type of complex distributed software system, which executes in an open, uncertain and dynamic environment, and adapts itself to changes in the environment. An important problem in the researches of Internetware is how to automatically construct the Internetware application that realizes the new requirements resulted from changes in the environment. In this paper, we focus on the automated construction of an important realization artifact of an Internetware application: the class diagram. A feature-driven approach is taken to automatically construct class diagrams. The approach consists of two components: a feature model utilized to model all the requirements that an Internetware application has to realize in different environments; the transformation rules from this feature model to class diagrams for automated class diagram construction. With this approach, once the requirements specific to an environment is given, the class diagram realizing the requirements can be constructed with the transformation rules automatically. To support the formal specification of the transformation rules, we design a transformation description language TDL4CD. Furthermore, several criteria for checking the validity of transformation rules written in TDL4CD is provided to support the construction of class diagrams. The usability of TDL4CD, as well as the feasibility of automatically constructing a class diagram with transformation rules in TDL4CD are preliminarily evaluated with 2 case studies.

The internetware system is a complex and distributed self-adaptive system, which challenges the method for making adaptation plans. Rule based approaches are very efficient to make plans in adaptive systems. To enable effective rule-based adaptation, we need to write a set of well behaved self-adaptive rules which could always lead to desirable states. This adaptive rules-set needs to be correct, com- plete, conflicts-free and well satisfy user goals, and it should updates according to user preferences. However, it is a difficult task for sys- tem users to define such a set of rules. To resolve this problem, we provide an rule generation engine, which could automatically generate well behaved self-adaptive rules according to user pref- erences. The rule generation engine is realized by a three-stage algorithm: stage 1 integrates user goals and user preferences, stage 2 establishes 1-1 tracing relationship between a context state and its desirable software configuration, stage 3 extracts self-adaptive rules from the tracing relationship between context states and software configurations. We will apply this engine to generate self-adaptive rules for a smart phone system, and evaluate the quality of generated self-adaptive rules.

Software product line engineering (SPLE) is a widely adopted approach to systematic software reuse. One basic research issue in SPLE is the product derivation problem, which focuses on how to derive software products from reusable software assets efficiently. In this paper, we focus on a sub-problem of product derivation: the problem of automated use case derivation, i.e. deriving the use cases of a software product in an automated way. We take a feature-oriented approach to this problem, an approach involving two components: a feature model, and the transformation information from the feature model to a set of use cases. In particular, we propose a transformation description language (TDL) to specify the transformation information from a feature model to a set of related use cases, and to support automated derivation of use cases corresponding to a valid feature model configuration. In addition, we also propose a set of criteria to check the validity of a TDL program. Three case studies have been conducted to demonstrate the usability of TDL and the feasibility of the automated use case derivation process based on TDL programs.

Integrating the computing process and the physical process, cyber-physical systems (CPS) pose many challenges to the system analysis and modeling. While most of the existing work focuses on developing the precise and formal model of CPS, little attentions have been given to the early requirements analysis and modeling which focuses on what the users' requirements are and what the software and physical domains of CPS will do to meet the users' requirements. In this paper, we provide an approach for early requirements analysis and modeling of CPS. This approach proposes to build the structure model to capture the system architecture, and the goal model to capture the refinement relationships between the users' requirements and the assumptions and requirements on the domains in CPS. These models help to build a clear understanding about CPS between the users and the designers and pave the way to define the precise and formal model. What these models are and how to build them are illustrated through a cruise control system.

On-Functional Requirements (NFRs) are vital for the success of software systems. Generally speaking, NFRs are some implicit expectations about how well the software will work, often known as software quality. For building better software, the NFRs should be considered as criteria for design decision. However, different NFRs may produce different criteria on the implementation strategies of the software functions. A trade-off analysis is needed for getting an optimal plan during design decision to satisfice NFRs as well as possible. By focusing on the NFRs that can be quantitatively specified, this paper proposes an approach to finding such an optimal solution for helping to make better decision. This approach regards the NFRs as the constraints on the implementation strategies of the software functions and models the selection of implementation strategies as a 0-1 programming problem. Then, a 0-1 programming solver can be used to find the optimal solution. An example is given to demonstrate the feasibility of this approach.

Internetware denotes a kind of complex distributed software system, which executes in an open, uncertain and dynamic environment, and adapts itself to changes in the environment. An important problem related to the development of Internetware applications is how to define their requirements. Traditional requirements modeling methods work well with software applications deployed in predictable environment, but cannot deal with Internetware applications, which have to identify and adapt themselves to the unpredictable situations of their environment. The self-adaptation characteristic of Internetware applications introduces challenges to the effective modeling of the requirements of Internetware applications. In this paper, we carry out a preliminary study on requirements modeling methods for self-adaptive software systems. In particular, we focus on how existing requirements modeling methods address the challenges caused by self-adaptation and what are the advantages and disadvantages of their solutions. By doing this study, we aim to identify the essential capabilities or properties that a requirements modeling method should possess so as to support the requirements modeling of self-adaptive software systems like Internetware.

Large modern software systems are often organized as product lines, requiring specialists to configure variability models before delivering a product. Variability models capture both the commonality and variability of different products, and help detect the configurations errors. Existing approaches can recommend fixes for the errors automatically. However, the recommended fixes are sometimes large and complex, and existing approaches lack guidance to help users identify a desirable fix. This paper proposes an approach to provide such guidance using dynamic priorities. The basic idea is to first generate one fix, and then gradually reach the desirable fix based on user feedback. To this end, our approach (1) automatically translates user feedback into a set of implicit priority levels on configuration variables, using five priority assignment and adjustment strategies and (2) efficiently generates potential desirable fixes by calculating new values for the variables with low priority. The experiments on real variability models show that we can reduce up to 89% of the fixes, and up to 98% of the variables shown to the user, compared to when no priorities are used.

Self-adaptive software systems can adjust their behaviors at runtime to respond to the context changes. To operationalize the adaptive mechanism, feedback loops have been advocated in many works. However, most of existing works focus on the architecture design to realize the feedback loops. How to model the required feedback loops remains an issue. In this paper, we propose a problem oriented approach for this issue. This approach models the system composed by the self-adaptive software and its context as an adaptive control system which is equipped with two kinds of feedback loops: context-aware feedback loops and requirements-aware feedback loops. To model the feedback loops, we identify five classes of software problems to address the different concerns of the adaptive requirements behind the feedback loops. We illustrate our idea by applying it to a cruise control system.

Feature-oriented analysis and modeling is widely accepted in software reuse, which consists of two major phases that should be taken seriously. The first is to construct a feature model, and the second is to configure products based on the feature model attained in the first. This paper presents a matrix-based approach to constructing and configuring feature models, whose main advantage is its scalability compared to traditional graphic-based feature models, and the supporting tool is presented to demonstrate its feasibility.

Feature models provide an effective way to organize and reuse requirements in a specific domain. A feature model consists of a feature tree and cross-tree constraints. Identifying features and then building a feature tree takes a lot of effort, and many semi-automated approaches have been proposed to help the situation. However, finding cross-tree constraints is often more challenging which still lacks the help of automation. In this paper, we propose an approach to mining cross-tree binary constraints in the construction of feature models. Binary constraints are the most basic kind of cross-tree constraints that involve exactly two features and can be further classified into two sub-types, i.e. requires and excludes. Given these two sub-types, a pair of any two features in a feature model falls into one of the following classes: no constraints between them, a requires between them, or an excludes between them. Therefore we perform a 3-class classification on feature pairs to mine binary constraints from features. We incorporate a support vector machine as the classifier and utilize a genetic algorithm to optimize it. We conduct a series of experiments on two feature models constructed by third parties, to evaluate the effectiveness of our approach under different conditions that might occur in practical use. Results show that we can mine binary constraints at a high recall (near 100% in most cases), which is important because finding a missing constraint is very costly in real, often large, feature models.

Feature models provide an effective way to capture commonality and variability in a specific domain. Constructing a feature model needs a systematic review of existing software artifacts in a domain and is always a collaboration-intensive activity. However, existing feature modeling methods and tools lack explicit support of such collaborations. In this paper, we present an environment for feature modeling that promotes the collaboration between stakeholders as the basis of creating and evolving a feature model. We present concepts, methods, and a tool to show the feasibility of constructing feature models collaboratively, as well as how to integrate this environment with traditional feature modeling methods.

In the software development, most stakeholders cannot clearly and objectively express their needs for the envisioned software systems. In this paper, we propose a problem-driven collaborative requirements elicitation approach, with the purpose of helping identify and extract the requirements of the Internetwares (a complex and new software paradigm). The basic idea of our approach is that the requirements of the software systems should be stated by stakeholders in an objective way (i.e. problem-identifying-solving way). That is, first identify the problems existed in the as-is problem domain, and then find the solutions to the problems. The solutions to the problems are the requirements of the envisioned software systems. To this end, we propose the structure of problems and a collaborative process for achieving the solutions.

Internetware is a paradigm of open, decentralized and continually evolvable software systems running on the Internet. In the development of Internetware, the enormous amount of its stakeholders brings challenges to the gathering of common and essential requirements among these stakeholders and continual evolution of the requirements. In this paper, we present a web-based collaborative feature modeling system (CoFM) developed as a platform for gathering, organizing, evaluating, and negotiating Internetware requirements. The basic idea is to express and organize requirements in terms of user-perceivable features of desired Internetware application, and to allow stakeholders to propose, evaluate and negotiate these features collaboratively, in a shared feature model of the application. During the collaboration, the application provider can discover the common and important features that need to be implemented at present, and the special but valuable features that might be provided in the future. Moreover, the provider can track the up-to-moment evolution of the features, which enables the provider to quickly respond to the changes in the Internetware requirements.

Stakeholders play critical roles in requirements elicitation, since they are the source of requirements, and the quality of elicited requirements is significantly influenced by the degree of stakeholders' participation and collaboration in elicitation. However, requirements elicitation is often obstructed due to the diversity in stakeholders' background and interests, especially in the different perspectives on the envisioned systems, the insufficient communication and common-understanding among them, and the different abilities to express requirements.

In the research of software reuse, feature models have been widely adopted to organize the requirements of a set of applications in a software domain. However, there still lacks an effective approach to minimizing analysts' participation in feature models' construction. In this paper, we propose a use case based semi-automatic approach to the construction of feature models. The basic idea of this approach is to first construct a set of feature models for individual applications(called application feature models, AFMs) in a software domain, then adjust, and merge the set of AFMs to form a feature model for this domain (called a domain feature model, DFM). The main characteristic of this approach is that it provides a set of rules and algorithms to make the construction of AFMs (from use cases) and the construction of DFMs (by merging a set of AFMs) be carried out automatically. A running example is used to illustrate the main characteristic and the feasibility of this approach.

Modern development environments often involve models with complex consistency relations. Some of the relations can be automatically established through "fixing procedures". When users update some parts of the model and cause inconsistency, a fixing procedure dynamically propagates the update to other parts to fix the inconsistency. Existing fixing procedures are manually implemented, which requires a lot of efforts and the correctness of a fixing procedure is not guaranteed.

The metamodel techniques and model transformation techniques provide a standard way to represent and transform data, especially the software artifacts in software development. However, after a transformation is applied, the source model and the target model usually co-exist and evolve independently. How to propagate modifications across models in different formats still remains as an open problem.

Component based software development (CBSD) becomes a popular paradigm for Internet based systems. Compared to other popular paradigms, CBSD supports the development from reusable components other than the development from the scratch. Consequently, modeling becomes more important than programming and the modeling techniques in traditional paradigms have to be changed more or less. Particularly, improper selection and misuse of modeling techniques would prevent the target system from benefiting from CBSD and even make the project fail. For helping researchers and practitioners to equip with CBSD, this tutorial will provide basic knowledge and skill of modeling component based systems systematically. Firstly, we will introduce the technical and non-technical motivations of CBSD with emphasis on software reuse which puts a significant impact on modeling. Secondly, we will present a systematic approach to modeling component based systems with a set of existing well-proved modeling techniques, including feature modeling for requirements specification, architecture modeling for abstract design, and object oriented modeling for detailed design. These modeling techniques and a real-life project will be discussed in details in the rest of the tutorial.

Identification of crosscutting concerns at the requirements level is important for the modularization and evolution of requirements, and has attracted many research interests. This paper proposes a feature-oriented approach to the identification of crosscutting requirements based on feature dependency analysis. In this approach, features are used as basic elements to organize the requirements space, and two kinds of dynamic dependencies (i.e. interactions and weavings) between features are analyzed to find out the candidate crosscutting requirements and their influence on other requirements. A case study is also used to illustrate the application of this approach

Feature models have been widely adopted in software reuse to organize the requirements of a set of similar applications in a software domain/product line. However, in most feature-oriented methods, the construction of feature models heavily depends on the domain analysts' personal understanding, and the work of constructing feature models from the original requirements of sample applications is often tedious and ineffective. This paper proposes a semiautomatic approach to constructing feature models based on requirements clustering, which automates the activities of feature identification, organization and variability modeling to a great extent. The underlying idea of this approach is to analyze the relationships between individual requirements and cluster tight-related requirements into features. With the automatic support of this approach, good quality feature models can be constructed in a more effective way. A case study is also provided to show the feasibility of this approach.

There are many researches on requirements dependencies. However, most of them limit their views to the requirements phase of software development, few focus on the roles of requirements dependencies in the solution space of software. This paper presents a feature-oriented approach to modeling requirements dependencies. A feature is a set of tight-related requirements from user/customer-views. The feature-orientation provides a modular way to organize requirements and a proper granularity to analyze requirements dependencies. In this approach, we care about not only static feature dependencies (i. e. refinements and constraints), but also feature dependencies at the specification level (namely influences) and, furthermore, dynamic feature dependencies (namely interactions). Moreover, we also explore the underlying connections between these four kinds of feature dependency. By this way, this approach gives a more complete view of how requirements dependencies influence the whole process of software development.