Schema evolution of mimic storage systems is a time-consuming and error-prone task due to the redundant development of heterogeneous executors. The ORM-based proxy requires an entire class to represent the structure of a data table. There lacks domain-specific code recommendation techniques to boost storage development. To address this issue, we design a novel type of code context, i.e. schema context, that combines features of code text, syntax and structure. Regarding the requirements of class-level granularity, we focus on behavior and attribute in code syntax, and use element position and structural metrics to mine the hidden relationships. Based on schema context and an existing inference mode, we propose SchemaRec to recommend ORM-related class for the database executors once one of them has been changed. We conduct experiments with 110 open-source projects, and the results show that SchemaRec obtains more accurate results than Lucene, DeepCS, QobCS and SEA in terms of Top-1, Top-10 and MRR accuracy due to the better ability of context representation. We also find that code syntax is the most important information because it involves behavior and attribute information of ORM-related classes.

The integration of an ensemble of deep learning models has been extensively explored to enhance defense against adversarial attacks. The diversity among sub-models increases the attack cost required to deceive the majority of the ensemble, thereby improving the adversarial robustness. While existing approaches mainly center on increasing diversity in feature representations or dispersion of first-order gradients with respect to input, the limited correlation between these diversity metrics and adversarial robustness constrains the performance of ensemble adversarial defense. In this work, we aim to enhance ensemble diversity by reducing attack transferability. We identify second-order gradients, which depict the loss curvature, as a key factor in adversarial robustness. Computing the Hessian matrix involved in second-order gradients is computationally expensive. To address this, we approximate the Hessian-vector product using differential approximation. Given that low curvature provides better robustness, our ensemble model was designed to consider the influence of curvature among different sub-models. We introduce a novel regularizer to train multiple more-diverse low-curvature network models. Extensive experiments across various datasets demonstrate that our ensemble model exhibits superior robustness against a range of attacks, underscoring the effectiveness of our approach.

ABSTRACT The DHR architecture provides a revolutionary security defense structure for cyberspace. The multimode ruling in DHR is expected to alleviate the oracle problem, which still suffers from the existence of common model vulnerability. In this work, we design a test segmentation method to transform multimode ruling to a metamorphic testing problem. The text test input that causes inconsistency of heterogeneous executors is converted to a condition set, and we extract subsets of conditions based on its syntax tree. The original test can exploit a specific vulnerability, the follow‐up tests are composed by different subsets of conditions within the original test. We collect the execution matrix for the follow‐up tests to analyse the impact of each subset of conditions on ruling decision. Metamorphic relations are extracted based on the localization of independent condition, that is, the subsets of conditions that can impact ruling decision independently. The executors in an inconsistent ruling should be examined with metamorphic testing methods, rather than traditional majority voting mechanism. The proposed test segmentation and improved multimode ruling methods are evaluated on two DHR‐based cases, SQL injection in cyber‐range system and deserialization attack in ‐ project. The experimental results show that our test segmentation can help to locate malicious expressions and the metamorphic testing‐based multimode ruling can generate more correct results than majority voting mechanism with an average 15.8% performance loss.

Software documents are commonly processed by natural language processing (NLP) libraries to extract information. The libraries provide similar functional APIs to achieve NLP tasks, numerous toolkits result in a problem of selection. In this work, we propose a method to combine the strengths of different NLP libraries to avoid the subjective selection of a specific NLP library. The combined usage is conducted through two steps, i.e. document-level selection of primary NLP library and sentence-level overwriting. The primary NLP library is determined according to the overlap degree of the results. The highest overlap degree indicated the most effective NLP library on a specific NLP task. Through sentence-level overwriting, the possible fine-gained improvements from other libraries are extracted to overwrite the outputs of primary library. We evaluate the combined method with six widely used NLP libraries and 200 documents from three different sources. The results show that the combined method can generally outperform all the studied NLP libraries in terms of accuracy. The finding means that our combined method can be used instead of individual NLP library for more effective results.

Event-driven architecture is one of the common software architecture patterns.In the process of software evolution, the deviation and corrosion often occur to architecture, which leads to larger deviation between actual software architecture and design architecture.Therefore, it is of great significance to study the approach of software architecture identification and refactoring.To solve this problem, we propose an identification and refactoring approach of event-driven based on ontology, i.e., IRABO.We evaluated IRABO on 50 open-source projects and the results show that it performs effectively and efficiently.

It is difficult to keep software architecture up to date with code changes during software evolution. Inconsistency is caused by the limitations of standard development specifications and human power resources, which may impact software maintenance. To solve this problem, we propose an incremental software architecture recovery (ISAR) technique. Our technique obtains dependency information from changed code blocks and identifies different strength-level dependencies. Then, we use double classifiers to recover the architecture based on the method of mapping code-level changes to architecture-level updates. ISAR is evaluated on 10 open-source projects, and the results show that it performs more effectively and efficiently than the compared techniques. We also find that the impact of low-quality architectural documentation on effectiveness remains stable during software evolution.

Trust relationships have an important effect on coalition formation. In many real scenarios, agents usually cooperate with others in their trusted social networks to form coalitions. Therefore, the trust value between agents should constrain the utility of forming coalitions when cooperating. At the same time, most studies ignore the impact of the number of coalitions in coalition structure. In this paper, the coalition formation of trust‐utility relationship in social networks is researched. Each node represents an agent, and the trust‐utility networks that connect the agents constrain coalition formation. To solve the task assignment problem, this paper proposes a greedy algorithm which is based on the edge contraction. Under the premise of ensuring the agent’s individually rationality, this algorithm simulates the formation process of coalitions between agents through continuous edge contraction and constrains the number of forming coalitions to k to solve the problem of coalition structure. Finally, the simulation results show that our algorithm has great scalability because of the ability of solving the coalition structure on a large‐scale agent set. It can meet the growing demand for data intensive applications in the Internet of things and artificial intelligence era. The quality of the solution is much higher than other algorithms, and the running time is negligible.

Comments are beneficial for developers to understand and maintain the code in software development life cycle. Well-commented code can generally help developers to resolve issues efficiently. Due to the complexity of code implementation, code comments may be generated to represent different types of information. And it is hard to keep all the code well-commented in real-world projects. In this case, it is meaningful to investigate how the different types of comments impact the resolution of issues. Then we can maintain the code comments purposefully, and we can also provide some suggestions for the comment generation techniques. To analyze the efforts of different comments on issue resolution, we classify code comments into two categories, i.e., functionality-aspect and non-functionality-aspect comments. In this paper, we analyze the effects of 53k pieces of code comments on the issues from 10 open-source projects within a period of 24 months. The results show that the majority of code comments are used to represent the functionality, e.g., the summary and purpose of code. Nevertheless, the other non-functionality-aspect comments have much stronger correlation with the resolution of software issues. For the resolved patches, the non-functionality-aspect comments are more frequently to be updated or added than the functionality-aspect comments. These findings confirm the important role of non-functionality-aspect comments during issue resolution, although their proportion is far less than that of functionality-aspect comments.

The current evaluation of API recommendation systems mainly focuses on correctness, which is calculated through matching results with ground-truth APIs. However, this measurement may be affected if there exist more than one APIs in a result. In practice, some APIs are used to implement basic functionalities (e.g., print and log generation). These APIs can be invoked everywhere, and they may contribute less than functionally related APIs to the given requirements in recommendation. To study the impacts of correct-but-useless APIs, we use utility to measure them. Our study is conducted on more than 5,000 matched results generated by two specification-based API recommendation techniques. The results show that the matched APIs are heavily overlapped, 10% APIs compose more than 80% matched results. The selected 10% APIs are all correct, but few of them are used to implement the required functionality. We further propose a heuristic approach to measure the utility and conduct an online evaluation with 15 developers. Their reports confirm that the matched results with higher utility score usually have more efforts on programming than the lower ones.

Context-aware API recommendation techniques aim to generate a ranked list of candidate APIs on an editing position during development. The basic context used in traditional API recommendation mainly focuses on the APIs from third-party libraries, limit or even ignore the usage of project-specific code. The limited usage of project-specific code may result in the lack of context information, and degrade the effectiveness of API recommendation. To address this problem, we introduce a novel type of context, i.e., hierarchical context, which can leverage the hidden information of project-specific code by analyzing the call graph. In hierarchical context, a project-specific API is presented as a sequence of low-leveled APIs from third-party libraries. We propose an approach, i.e., HiRec, which builds on the basis of hierarchical context. HiRec is evaluated on 108 projects and the results show that HiRec can obtain much more accurate results than all the other selected approaches in terms of top-5 and top-10 accuracy due to the strong ability of context representation. And HiRec performs closely to the outstanding tools in terms of top-1 accuracy. The average time of recommending execution is less than 1 seconds in most cases, which is acceptable for interaction in an IDE. Unlike current approaches, the effectiveness of HiRec is not impacted much by editing positions. And we can obtain more accurate results from HiRec with larger sizes of training data and hierarchical context.

The single-axis rotational inertial system (RINS) can average out the biases of inertial sensor perpendicular to rotation axis. However, these inertial sensor biases will introduce Schuler oscillation and saw-tooth error in the velocity output. Redundant RINS configuration is widely used in the ships and underwater vehicles. However, the information fusion between the redundant systems is ignored. In this paper, a joint error model and a measurement model are constructed for the redundant RINSs, whereby a novel Kalman filter is designed to estimate the inertial sensor biases. The designed Kalman filter does not require external reference information aiding. Based on the estimates of the inertial sensor bias, a velocity error prediction model is designed to predict the velocity error caused by inertial sensor biases. By velocity error output correction, the velocity fluctuation is decreased by 30%. As a typical application, the compensated velocity output from the master RINS is provided for the slave inertial navigation system (INS) to accomplish transfer alignment. Simulation test and experiments are conducted to verify the effectiveness of the proposed method.

A multi-person tracking method is proposed concerning how to conquer the difficulties such as occlusion and changes in appearance which makes algorithm hard to get the correct positions of object. First, we indicate whether the target is blocked or not, through computing the Reliability of Tracklets (RT) based on the length of tracklets, appearance affinity and the size. Then, we propose a “correct” observation sample selection method and only update the weights of particle filter when the RT is high. Last, the greedy bipartite algorithm is used to realize data association. Experiments show that tracking can be successfully achieved even under severe occlusion.

Automated program repair can save tremendous manual efforts in software debugging. Therefore, a huge body of research efforts have been dedicated to design and implement automated program repair techniques. Among the existing program repair techniques, genetic-programming-based techniques have shown promising results. Recently, researchers found that random-search-based and adaptive program repair techniques can also produce effective results. In this work, we performed an extensive study for four program repair techniques, including genetic-programming-based, random-search-based, brute-force-based and adaptive program repair techniques. Due to the extremely large time cost of the studied techniques, the study was performed on 153 bugs from 9 small to medium sized programs. In the study, we further investigated the impacts of different programs and test suites on effectiveness and efficiency of program repair techniques. We found that techniques that work well with small programs become too costly or ineffective when applied to medium sized programs. We also computed the false positive rates and discussed the ratio of the explored search space to the whole search space for each studied technique. Surprisingly, all the studied techniques except the random-search-based technique are consistent with the 80/20 rule, i.e., about 80% of successful patches are found within the first 20% of search space.