In the continuous iteration of software, synchronizing the updates of test code and production code is crucial for ensuring project quality. However, in actual development, test code maintenance often lags behind the evolution of production code, which can lead to issues such as invalid functionality verification. Existing test code repair methods based on pre-trained models or Large Language Models (LLMs) show less effective or low generalization due to their lack of precise contextual awareness or strong limitations in use scenarios.

Blockchain data encoding has been proposed as a solution to reduce the storage load on full nodes in blockchain systems. However, the high latency and cost associated with the decoding process make coding techniques difficult to apply to frequently accessed blockchain data. This limitation is particularly significant in blockchain applications for the Internet of Things, where nodes generally have limited storage capabilities. To address this issue, we propose a novel blockchain encoding storage architecture. We classify the frequently used state data in blockchain into hot data and cold data, with hot data stored normally and cold data encoded. In addition, we designed a new transaction processing mechanism that prioritizes transactions involving specific data within a single block production process, thereby reducing the frequency of data decoding. At the same time, we use erasure codes and Merkle trees to ensure the security of the stored data. Experimental results show that in our approach, the account data storage on full nodes is significantly lower than that of normal full nodes, while the block transaction volume and block generation time are not substantially different from the normal state. Finally, we verify the robustness of our method against node dropouts through experiments.

Commits messages play a crucial role in helping developers efficiently comprehend code modifications. Due to the time pressure of project iteration or poor message-writing practices, many commits suffer from missing messages. To address this issue, researchers have explored the automated generation of commit messages. Because of the truncation mechanism of the learning-based model, most of the current studies focus on code changes appearing at the beginning of a commit into the model for commit message generation. This may not be the best strategy for commit message generation because each code change in a commit contributes unequally to its overall purpose. To better generate commit messages, we propose a novel method that identifies the core code change in a commit for commit message generation. Specifically, we employ a method to predict the relative importance of the classes contained in a commit, and the code change of the class with the highest importance score (i.e., core change) is used to generate the commit message. Incorporating core change information can boost the performance of other existing methods (such as NMT, NNGen, and CoreGen). Building on this insight, we develop CCGen—a Core Change-Based Generation model that integrates a Transformer architecture with CodeBERT-enhanced encoding to leverage code semantics. The experiment demonstrates that the proposed method for commit message generation outperforms the state-of-the-art by 18.47% on average across seven metrics including 19.97 on ROUGE-L.

Coded blockchain leverages error correction codes to create coded fragments that are then stored in a distributed manner by nodes. It significantly reduces the storage requirement of conventional blockchain. A key limitation, however, is that as nodes store arbitrary coded fragments, which leads to high transmission overhead or decoding failure. To this end, this paper introduces a novel reinforcement learning approach to assign coded fragments to nodes. Specifically, nodes learn to store coded fragments based on feedback from other nodes, which considers their block decoding process. To study its efficacy, this paper compares the proposed approach with existing centralized and distributed coded fragments assignment solutions. The simulation results show that our approach outperforms existing solutions by 6 % in terms of loss function and by 20 % in transmission overhead.

Abstract Researchers have recently achieved significant advances in deep learning techniques, which in turn has substantially advanced other research disciplines, such as natural language processing, image processing, speech recognition, and software engineering. Various deep learning techniques have been successfully employed to facilitate software engineering tasks, including code generation, software refactoring, and fault localization. Many studies have also been presented in top conferences and journals, demonstrating the applications of deep learning techniques in resolving various software engineering tasks. However, although several surveys have provided overall pictures of the application of deep learning techniques in software engineering, they focus more on learning techniques, that is, what kind of deep learning techniques are employed and how deep models are trained or fine-tuned for software engineering tasks. We still lack surveys explaining the advances of subareas in software engineering driven by deep learning techniques, as well as challenges and opportunities in each subarea. To this end, in this study, we present the first task-oriented survey on deep learning-based software engineering. It covers twelve major software engineering subareas significantly impacted by deep learning techniques. Such subareas spread out through the whole lifecycle of software development and maintenance, including requirements engineering, software development, testing, maintenance, and developer collaboration. As we believe that deep learning may provide an opportunity to revolutionize the whole discipline of software engineering, providing one survey covering as many subareas as possible in software engineering can help future research push forward the frontier of deep learning-based software engineering more systematically. For each of the selected subareas, we highlight the major advances achieved by applying deep learning techniques with pointers to the available datasets in such a subarea. We also discuss the challenges and opportunities concerning each of the surveyed software engineering subareas.

Abstract In software development and maintenance, code comments can help developers understand source code and improve communication among developers. However, developers sometimes neglect to update the corresponding comment when changing the code, resulting in outdated comments (i.e., inconsistent codes and comments). Outdated comments are dangerous and harmful and may mislead subsequent developers. More seriously, the outdated comments may lead to a fatal flaw sometime in the future. To automatically identify the outdated comments in source code, we proposed a learning‐based method, called CoCC, to detect the consistency between code and comment. To efficiently identify outdated comments, we extract multiple features from both codes and comments before and after they change. Besides, we also consider the relation between code and comment in our model. Experiment results show that CoCC can effectively detect outdated comments with precision over 90%. In addition, we have identified the 15 most important factors that cause outdated comments and verified the applicability of CoCC in different programming languages. We also used CoCC to find outdated comments in the latest commits of open source projects, which further proves the effectiveness of the proposed method.

Abstract Ethereum, as a leading blockchain platform, has attracted a significant number of practitioners. These practitioners require a platform for communication and collaborative problem‐solving, which led to Ethereum Stack Exchange (ESE), a Q&A site dedicated to Ethereum‐related issues. While the Q&A site facilitates communication among practitioners, it also introduces new challenges. Practitioners adopt code snippets from Q&A sites to address problems encountered. However, the quality of code snippets on ESE remains largely unexplored. Vulnerabilities and gas‐inefficient patterns in ESE may spread to the code in Ethereum and threaten its regular operation. In this article, we conduct an empirical study investigating the distribution of vulnerabilities and gas‐inefficient patterns in ESE. Further, we analyze the potential impact of vulnerabilities and gas‐inefficient patterns from ESE on Ethereum. However, we encounter a problem during the vulnerability and gas‐inefficient pattern detection. Established smart contract analysis tools in the mainstream realm necessitate complete source code files for thorough analysis, while codes on ESE are often incomplete code snippets. To address this, we introduce the AST‐based code clone detection technique to construct detectable files corresponding to code snippets. This enables us to detect vulnerabilities and gas‐inefficient patterns in code snippets. In the end, our findings demonstrate that 11.18% of the contract‐level code snippets and 4.06% of function‐level code snippets in ESE have vulnerabilities. And 27.21% of contract‐level code snippets and 17.89% of function‐level code snippets contain gas‐inefficient patterns. The additional consumption caused by the gas‐inefficient pattern in ESE is approximately $1,695,002. Based on these findings, we provide recommendations for both ESE and its users, aiming to foster collaborative efforts and create a more reliable Q&A site for practitioners.

Comments play a crucial role in code comprehension and maintenance. This is particularly vital when the code is changed, as comments should be promptly updated to maintain consistency between the code and the comments. Existing comment update methods usually treat code as natural language text, ignore the information of code structure, and often fail when code changes are not associated with comment updates (called a non-code-indicative update (NCIU)). Therefore, we propose a Transformer and Graph neural network-based Comment UPdate method (TG-CUP). The model integrates the information of old comment, code edit sequence, and AST-Difference Graph to update the outdated comments. The experimental results show that TG-CUP increased by 5.16% and 2.23% compared with the most advanced methods on Accuracy and Recall@5, and the performance on NCIUs is improved as well.

Smart contracts are programs that permanently store and automatically execute on the blockchain system such as Ethereum. Due to the non-tamperable nature of the underlying blockchain, smart contracts are difficult to update once deployed, which requires redeploying the contracts and migrating the data. It means that the observation of smart contract evolution in the real world makes more sense. Hence, in this paper, we conducted the first large-scale empirical study to characterize the evolution of smart contracts in Ethereum. For evolution identification, we presented a contract similarity-based search algorithm, digEvolution, and evaluated its effectiveness with five different search strategies. Then we applied this algorithm to 80,152 on-chain contracts we collected from Ethereum, to dig out the evolution among these contracts. We then explored three research questions. We first studied whether the evolution of smart contracts is common (RQ1), then we studied how do the Gas consumption (RQ2) and the vulnerability (RQ3) of smart contracts vary during the evolution. Our research results show that the evolution of smart contracts is not very common. There are some contract components that have vulnerability but still be called by users. The Gas consumption of most smart contracts doesn’t vary during the evolution, contract is Gas-efficient before and after the evolution. The vulnerability of most smart contracts doesn’t vary during the evolution, both are secure before and after the evolution.

Code comment plays an important role in program understanding, and a large number of automatic comment generation methods have been proposed in recent years. To get a better effect of generating comments, many studies try to extract a variety of information (e.g., code tokens, AST traverse sequence, APIs call sequence) from source code as model input. In this study, we found that the bytecode compiled from the source code can provide useful information for comment generation, hence we propose to use the information from bytecode to assist the comment generation. Specifically, we extract the control flow graph (CFG) from the bytecode and propose a serialization method to obtain the CFG sequence that preserves the program structure. Then, we discuss three methods for introducing bytecode information for different models. We collected 390,000 Java methods from the maven repository, and created a dataset of 101,124 samples after deduplication and preprocessing to evaluate our method. The results show that introducing the information extracted from the bytecode can improve the BLEU- 4 of 7 comment generation models.

Automatic code summarization, also known as code comment generation, has been proven beneficial for developers to understand better and maintain software projects. However, few research works have investigated the robustness of such models. Robustness requires that the model sustains the quality of the output summaries in the presence of perturbations to the inputs. In this paper, we provide an in-depth study of the robustness of code summarization models. We propose CREATE (Code summaRization modEl’s Adversarial aTtackEr), an approach for performing adversarial attacks against the model. This approach can generate adversarial samples to mislead the model and explore its robustness while ensuring these samples are compilable and semantically similar. We attack mainstream code summarization models with a large-scale available Java dataset to evaluate the effectiveness and efficiency of our approach. The experimental results indicate that CREATE’s attack effectiveness and efficiency surpasses other baselines, causing a decrease in the quality of generated comments by at least 40%. Furthermore, we investigate the magnitude of perturbation caused by CREATE during adversarial attacks, and the results show that the similarity between the adversarial samples generated by CREATE and the input code is approximately 0.8, demonstrating that it induces more minor perturbations compared to other baselines. Finally, we utilize CREATE for adversarial training of the model. Through experimentation, this approach indeed effectively enhances the model’s robustness.

Commit messages provide important information for comprehending the code changes, and a number of researchers try to generate commit messages by using an automatic way. These research on commit message generation has profited from the code tokens or code structures such as AST. Since the edit sequence of code change is also important for capturing the code change intent, we propose a new commit message generation method called ESGen, which extracts AST edit sequences of code changes as model input. Specifically, we employ an O(ND) difference algorithm to extract the edit sequence from AST by comparing the ASTs before and after applying the code changes. Then, we construct a Bi-Encoder, which encodes the textual information and the AST edit sequence information of code change. The experimental results show that ESGen outperforms other baseline models, improving the BLEU-4 to 15.14. Also, when applying the edit sequence to 7 baseline models, they improve the BLEU-4 scores of these models by an average of 8.5%. Additionally, a human evaluation confirmed the effectiveness of ESGen in generating commit messages.

Although smart contracts are immutable once they are deployed, the reality is that they need upgrades to fix bugs or add new features. Nowadays, there are a few upgrade methods in Ethereum, some of which can change the contract without changing the contract address that users interact with. This upgrade way increases potential danger and results in users' distrust, because it may secretly change the function of the contract and cause users financial loss. We examine two of these upgrade methods, i.e., proxy pattern and metamorphic contract. For the proxy pattern, we propose a bytecode-based method for detecting these upgradeable contracts, which achieves a 99.37% F1-score. We use the bytecode-based method to detect the contracts in the first 12 million blocks of Ethereum and find 126,500 upgradeable contracts. For the metamorphic contracts, we employ an Ethereum replay tool to replay the transactions and find the metamorphic contracts according to the SELFDESTRUCT and CREATE2 instructions. We find that 64.3% of the contracts upgraded using this way are malicious MEV bots. Finally, we summarize the reasons for smart contract upgrades and make development recommendations.

High-quality and appropriate commit messages help developers to quickly understand and track code evolution, which is crucial for the collaborative development and maintenance of software. To relieve developers of the burden of writing commit messages, researchers have proposed various techniques to generate commit messages automatically, among which learning-based techniques have proven to be promising.

GUI test repair is important to detect and repair obsolete test events to enhance the reliability of the software. From an interaction design perspective, designers usually design different routes to facilitate users to reach the same functional entry point. Based on this, we propose a novel test repair method to find paths with similar functions based on the feature coverage, to get as close as possible to the test target point during the repairing process, and to improve the effectiveness of the test fixing. A test extension algorithm is proposed to search for alternative event branches with similar features to the test script. Then, the sequence transduction probability is used to calculate the feature coverage of the mapping event paths in the updated version and guide the repair. Experiments conducted on popular applications demonstrate that the method can achieve a success rate of 79.63% in repairing tests, which significantly outperforms current approaches. The test-extension approach displays immense potential for optimizing test repairs.

Abstract In software evolution, keeping the test code co‐change with the production code is important, because the outdated test code may not work and is ineffective in revealing faults in the production code. However, due to the tight development time, the production and test code may not be co‐changed immediately by developers. For example, we analysed the top 1003 popular Java projects on GitHub and found that nearly 9.3% of cases (i.e., 464,417) did not update their production and test code at the same time, that is, the production code is updated first, and then the test code is updated at intervals. The result indicates that much test code will not be updated in time. In this paper, we propose a novel approach, Jtup, to remind developers to co‐change the production code and test code in time. Specifically, we first define the co‐changed production and test code as a positive instance, while unchanged test code (i.e., production code changed and test code unchanged) as a negative instance. Then, we extract multidimensional features from the production code to characterize the possibility of their co‐change, including code change features, code complexity features, and code semantic features. Finally, several machine learning‐based methods are employed to identify the co‐changed production and test code. We conduct comprehensive experiments on 20 datasets, and the results show that the Accuracy, Precision, and Recall achieved by Jtup are 76.7%, 78.1%, and 77.4%, which outperforms the state‐of‐the‐art method.

With the fast development of large software projects, automatic code summarization techniques, which summarize the main functionalities of a piece of code using natural languages as comments, play essential roles in helping developers understand and maintain large software projects. Many research efforts have been devoted to building automatic code summarization approaches. Typical code summarization approaches are based on deep learning models. They transform the task into a sequence-to-sequence task, which inputs source code and outputs summarizations in natural languages. All code summarization models impose different input size limits, such as 50 to 10,000, for the input source code. However, how the input size limit affects the performance of code summarization models still remains under-explored. In this article, we first conduct an empirical study to investigate the impacts of different input size limits on the quality of generated code comments. To our surprise, experiments on multiple models and datasets reveal that setting a low input size limit, such as 20, does not necessarily reduce the quality of generated comments. Based on this finding, we further propose to use function signatures instead of full source code to summarize the main functionalities first and then input the function signatures into code summarization models. Experiments and statistical results show that inputs with signatures are, on average, more than 2 percentage points better than inputs without signatures and thus demonstrate the effectiveness of involving function signatures in code summarization. We also invite programmers to do a questionnaire to evaluate the quality of code summaries generated by two inputs with different truncation levels. The results show that function signatures generate, on average, 9.2% more high-quality comments than full code.

A smart contract is a kind of code deployed on the blockchain that executes automatically once an event triggers a clause in the contract. Since smart contracts involve businesses such as asset transfer, they are more vulnerable to attacks, so it is crucial to ensure the security of smart contracts. Because a smart contract cannot be tampered with once deployed on the blockchain, for smart contract developers, it is necessary to fix vulnerabilities before deployment. Compared with many vulnerability detection tools for smart contracts, the amount of automatic fix approaches for smart contracts is relatively limited. These approaches mainly use defined pattern-based methods or heuristic search algorithms for vulnerability repairs. In this article, we propose RLRep , a reinforcement learning-based approach to provide smart contract repair recommendations for smart contract developers automatically. This approach adopts an agent to provide repair action suggestions based on the vulnerable smart contract without any supervision, which can solve the problem of missing labeled data in machine learning-based repair methods. We evaluate our approach on a dataset containing 853 smart contract programs (programming language: Solidity) with different kinds of vulnerabilities. We split them into training and test sets. The result shows that our approach can provide 54.97% correct repair recommendations for smart contracts.

Code commenting plays an important role in program comprehension. Automatic comment generation helps improve software maintenance efficiency. The code comments to annotate a method mainly include header comments and snippet comments. The header comment aims to describe the functionality of the entire method, thereby providing a general comment at the beginning of the method. The snippet comment appears at multiple code segments in the body of a method, where a code segment is called a code snippet. Both of them help developers quickly understand code semantics, thereby improving code readability and code maintainability. However, existing automatic comment generation models mainly focus more on header comments, because there are public datasets to validate the performance. By contrast, it is challenging to collect datasets for snippet comments, because it is difficult to determine their scope. Even worse, code snippets are often too short to capture complete syntax and semantic information. To address this challenge, we propose a novel S nippet C omment Gen eration approach called SCGen . First, we utilize the context of the code snippet to expand the syntax and semantic information. Specifically, 600,243 snippet code-comment pairs are collected from 959 Java projects. Then, we capture variables from code snippets and extract variable-related statements from the context. After that, we devise an algorithm to parse and traverse abstract syntax tree (AST) information of code snippets and corresponding context. Finally, SCGen generates snippet comments after inputting the source code snippet and corresponding AST information into a sequence-to-sequence-based model. We conducted extensive experiments on the dataset we collected to evaluate our SCGen . Our approach obtains 18.23 in BLEU-4 metrics, 18.83 in METEOR, and 23.65 in ROUGE-L, which outperforms state-of-the-art comment generation models.

An increasing number of investors are active on Ethereum, resulting in numerous transactions. These historical transactions can be applied to complete contract testing. For example, it can be used for gas optimization or contract repair to verify that improved contracts meet expectations. Most existing methods deploy private chains to use non-real transactions for contract verification instead of actual historical transactions on the Ethereum mainnet. The challenge of using actual historical transactions for verification is that Ethereum only records the latest state of the account and cannot restore the execution of historical transactions. Due to contract code changes in contract gas optimization, contract defect repair, and other scenarios, we need to test the execution of the contract code before and after the change. However, existing tools cannot customize and modify historical transactions for testing purposes. Therefore, we propose an efficient transaction replay platform,EthReplayer, which can not only replay the historical transactions of Ethereum quickly and faithfully but also realize the modification of transactions to achieve the purpose of testing with actual transactions. Experimental results show that our replay speed is 1.5 times the fastest available, and it only takes 29,594 seconds to replay 1,200 million blocks. In addition, it is applied to contract repair verification, gas optimization verification, and gas estimation, and the results prove the effectiveness ofEthReplayer.

The existence of software defects greatly restricts the application of software and may bring great economic losses. Defect prediction techniques based on file level or module level can help code reviewers quickly locate defects and fix them. In recent years, researchers have used natural language techniques to explore the defectiveness of code lines by analyzing the semantic information of the code lines. However, the appearance of defects is often associated with the syntactic information of the code. To fully use the syntax information associated with code lines, we propose a code line-level representation considering the coverage of the syntax node. Specifically, we add the syntax node to its corresponding coverage lines. Combining with the BiLSTM model, we propose a new line-level defect prediction model, SyntaxLineDP, which shows good performance achieving 0.72 and 0.62 for AUC and Balanced Accuracy respectively. SyntaxLineDP outperforms the state-of-the-art model and the popular static tools (e.g., ErrorProne, PMD). Specifically, In the within-project evaluation, the SyntaxLineDP model outperforms the start-of-the-art model by 15% and 27% on the Recall@Top20% LOC metric and the Effort@Top20% Recall metric respectively. In the cross-project evaluation, the SyntaxLineDP outperforms the start-of-the-art model by 7% and 42% on the Recall@Top20% LOC metric and the Effort@Top20% Recall metric respectively. Through ablation experiments, we studied how the selection of extended syntax information contributes to the detection and found out some key features that are helpful for the defect prediction task: number of infix expressions of code line, number of blocks of code line, and number of method invocation of the code line.

A smart contract is a self-executing program that is stored on the blockchain and runs when predetermined conditions are satisfied. Many frequent transactions involving asset transfers rely on smart contracts deployed on the blockchain, making them highly vulnerable to attack, thus it is essential to ensure the security of smart contracts. Since the smart contract is immutable once deployed, developers must try their best to fix existing vulnerabilities in advance to ensure security. Current approaches for automatic program repair on the smart contracts have mainly adopted the heuristic search algorithms or defined patterns to fix several well-defined types of vulnerabilities. They can only provide security code recommendations for developers in specific scenarios. We explore more general automated program repair of smart contracts in software history.To pave the way for studying code changes related to bug fix of smart contracts in software history, we present a labeled public dataset for method-level program repair task, containing over 12 typical insecure code patterns. Unlike bugs in traditional software, the vulnerabilities of smart contracts are more associated with access control and conditional statements as smart contracts pertain to financial assets. For this problem, we devise a novel double-encoder network and use a code representation designed for the smart contract based on syntax information to repair program. By implementing and evaluating our approach on new dataset comprised of over 10,000 program pairs, we demonstrate the superiority of our approach in both qualitative and quantitative aspects.

Abstract Bytecode is a form of instruction set designed for efficient execution by a software interpreter. Unlike human-readable source code, bytecode is even harder to understand for programmers and researchers. Bytecode has been widely used in various software tasks such as malware detection and clone detection. In order to understand the meaning of the bytecode more quickly and accurately and further help programmers in more software activities, we propose a bytecode comment generation method (called BCGen) using neural language model. Specifically, to get the structured information of the bytecode, we first generate the control flow graph (CFG) of the bytecode, and serialize the CFG with bytecode semantic information. Then a transformer model combining gate recurrent unit is proposed to learn the features of bytecode to generate comments. We obtain the bytecode by building the Jar packages of the well-known open-source projects in the Maven repository and construct a bytecode dataset to train and evaluate our model. Experimental results show that the BLEU of BCGen can reach 0.26, which outperforms several baselines and proves the effectiveness and practicability of our method. It is concluded that it is possible to generate natural language comments directly from the bytecode. Meanwhile, it is important to take structured and semantic information into account in generating bytecode comments.

Code comments are one of the important documents to help developers review and comprehend source code. In recent studies, researchers have proposed many deep learning models to generate the method header comments (i.e., method comment), which have achieved encouraging results. The comments in the method, which is called inline comment, are also important for program comprehension. Unfortunately, they have not received enough attention in automatic generation when comparing with the method comments. In this paper, we compare and analyze the similarities and differences between the method comments and the inline comments. By applying the existing models of generating method comments to the inline comment generation, we find that these existing models perform worse on the task of inline comment generation. We then further explore the possible reasons and obtain a number of new observations. For example, we find that there are a lot of templates (i.e., comments with the same or similar structures) in the method comment dataset, which makes the models perform better. Some terms were thought to be important (e.g., API calls) in the comment generation by previous study does not significantly affect the quality of the generated comments, which seems counter-intuitive. Our findings may give some implications for building the approaches of method comment or inline comment generation in the future.

As one of the most well-known programmer Q&A websites, Stack Overflow (i.e., SO) is serving tens of thousands of developers every day. Previous work has shown that many developers reuse the code snippets on SO when they find an answer (from SO) that functionally matches the programming problem they encounter in their development activities. To study how programmers reuse code on SO during project development, we conduct a comprehensive empirical study. First, to capture the development activities of programmers, we collect 342,148 modified code snippets in commits from 793 open-source Java projects, and these modified code can reflect the programming problems encountered during development. We also collect the code snippets from 1,355,617 posts on SO. Then, we employ CCFinder to detect the code clone between the modified code from commits and the code from SO, and further analyze the code reuse when programmer solves a programming problem during development. We count the code reuse ratios of the modified code snippets in the commits of each project in different years, the results show that the average code reuse ratio is 6.32%, and the maximum is 8.38%. The code reuse ratio in project commits has increased year by year, and the proportion of code reuse in the newly established project is higher than that of old projects. We also find that some projects reuse the code snippets from many years ago. Additionally, we find that experienced developers seem to be more likely to reuse the knowledge on SO. Moreover, we find that the code reuse ratio in bug-related commits (6.67%) is slightly higher than that of in non-bug-related commits (6.59%). Furthermore, we also find that the code reuse ratio (14.44%) in Java class files that have undergone multiple modifications is more than double the overall code reuse ratio (6.32%).

Developers may not understand the Gas mechanism of Ethereum, so many smart contracts consume a lot of unnecessary Gas. To address this issue, existing studies have proposed several methods to optimize the code of the contracts to reduce Gas consumption. To verify the effectiveness, most of the methods deploy a private chain to make verification. However, a more reasonable way is to employ the real transactions on Ethereum to trigger the contracts before and after optimization, and then compare the Gas consumption. To achieve this goal, we proposed a method, GOV, to estimate the Gas consumption of the optimized contract by using the real transactions on Ethereum. Our method enables the optimized contract to follow the execution path of the contract before optimization, thus solving the problem of inconsistent execution paths before and after optimization. A preliminary evaluation shows that GOV can effectively estimate the Gas consumption of optimized contract.

Abstract Code review is one of the common activities to guarantee the reliability of software, while code review is time-consuming as it requires reviewers to inspect the source code of each patch. A patch may be reviewed more than once before it is eventually merged or abandoned, and then such a patch may tighten the development schedule of the developers and further affect the development progress of a project. Thus, a tool that predicts early on how long a patch will be reviewed can help developers take self-inspection beforehand for the patches that require long-time review. In this paper, we propose a novel method, PMCost, to predict the reviewing rounds of a patch. PMCost uses a number of features, including patch meta-features, code diff features, personal experience features and patch textual features, to better reflect code changes and review process. To examine the benefits of PMCost, we perform experiments on three large open source projects, namely Eclipse, OpenDaylight and OpenStack. The encouraging experimental results demonstrate the feasibility and effectiveness of our approach. Besides, we further study the why the proposed features contribute to the reviewing rounds prediction.

Code review is a common software engineering practice of practical importance to reduce software defects. Review today is often with the help of specialized tools, such as Gerrit. However, even in a tool-supported code review involves a significant amount of human effort to understand the code change, because the information required to inspect code changes may distribute across multiple files that reviewers are not familiar with. Code changes are often organized as commits for review. In this paper, we found that most of the commits contain a salient class(es), which is saliently modified and causes the modification of the rest classes in a commit. Our user studies confirmed that identifying the salient class in a commit can facilitate reviewers in understanding code change. Inspired by the effectiveness of machine learning techniques in the classification field, we model the salient class identification as a binary classification problem and a number of discriminative features is extracted for a commit and used to characterize the salience of a class. The experiments results show that our approach achieves an accuracy of 88 percent. A user study with industrial developers shows that our approach can really improve the efficiency of reviewers understanding code changes in a reviewing scenario without using comment.

Change impact analysis (CIA) is a specialized process of program comprehension that investigates the ripple effects of a code change in a software system. In this paper, we present a boosting way for change impact analysis via mapping the historical change-patterns to current CIA task in a cross-project scenario. The change-patterns reflect the coupling dependencies between changed entities in a change set. A traditional CIA tool (such as ImpactMiner) outputs an initial impact set for a starting entity. To boost the traditional CIA tool, our approach retrieves an equivalent entity from various historical change sets for the starting entity. Then, the change-patterns between the equivalent entity and the rest of entities in the change set are mapped to the CIA task at hand. For current CIA task, if an entity in the initial impact set involves the similar change-pattern with the starting entity when comparing with the mapped change-pattern, we will reward the impacted confidence of the entity. Accuracy improvements are observed in the experiments when applying our boosting method to three famous CIA tools, i.e., ImpactMiner, JRipples and ROSE.

Smart contracts are programs that automatically execute on the blockchain system such as Ethereum. Everybody can write and deploy smart contracts on Ethereum, which causes a large collection of similar contracts via code reuse. In practice, code reuse in smart contract may amplify severe threats like security attacks, resource waste, etc. In this paper, we conduct an empirical study of code reuse in smart contracts for understanding the code reuse practice in the smart contract ecosystem. We first collect 146,452 open-source smart contract projects from Ethereum and then perform a detailed analysis. We first study how often the smart contract projects reuse and then we identify the top reused smart contracts and analyze how the developers revise smart contracts during reuse. Our research suggests that the code reuse in smart contract is quite frequent because about 26% contract code blocks are reused and the average time of reuse is 14.6. And the top reused contracts are almost all related to ERC20 token, which reveals that the current smart contract ecosystem is relatively homogenous. At last, we summarize 7 common types of code revision in smart contracts.

The color design is one of the important parts of GUI development. To gain an attractive color scheme, designers often seek inspiration from examples. However, transferring an example’s colors to a target web page is time-consuming and tedious. In this paper, we propose a method named AutoWPR to reuse the example web page’s colors for recoloring a web page. To preserve the semantic relations of web elements, we propose a clustering algorithm to group the related elements into a cluster. In order to make the recoloring result have similar color distributions to the example, we use the Random–Forest regression to learn human’s mappings and propose a top-down matching algorithm to generate a mapping between two web pages’ clusters. Then AutoWPR recolors the element with the matching element’s colors. We designed several experiments to evaluate the correctness of the clustering and matching algorithm. We also conducted some qualitative and quantitative experiments to evaluate the effectiveness of our results in helping recoloring. The results show that our method can generate a human-like recoloring result and help novice developers reuse the reference web page’s colors conveniently.

Summary Code comments convey information about the programmers' intention in a more explicit but less rigorous manner than source code. This information can assist programmers in various tasks, such as code comprehension, reuse, and maintenance. To better understand the properties of the comments existing in the source code, we analyzed more than 450 000 comments across 136 popular open‐source software systems coming different domains. We found that the methods involving header comments and internal comments were shown low percentages in software systems, ie, 4.4% and 10.27%, respectively. As an application of our findings, we propose an automatic approach to determine whether a method needs a header comment, known as commenting necessity identification. Specifically, we identify the important factors for determining the commenting necessity of a method and extract them as structural features, syntactic features, and textual features. Then, by applying machine learning techniques and noise‐handling techniques, we achieve a precision of 88.5% on eight open‐source software from GitHub. The encouraging experimental results demonstrate the feasibility and effectiveness of our approach.

Code commenting is a common programming practice of practical importance to help developers review and comprehend source code. In our developer survey, commenting has become an important, yet often-neglected activity when programming. Moreover, there is a lack of formal and automatic way in current practice to remind developers where to comment in the source code. To provide informative guidance on commenting during development, we propose a novel method CommentSuggester to recommend developers regarding appropriate commenting locations in the source code. Because commenting is closely related to the context information of source code, we identify this important factor to determine comment positions and extract it as structural context features, syntactic context features, and semantic context features. Subsequently, machine learning techniques are applied to identify possible commenting locations in the source code. We evaluated CommentSuggester using large datasets from dozens of open-source software systems in GitHub. The encouraging experimental results and user study demonstrated the feasibility and effectiveness of our commenting suggestion method.

Blockchain has attracted wide attention. A smart contract is a program that runs on the blockchain, and there is evidence that most of the smart contracts on the Ethereum are highly similar, as they share lots of repetitive code. In this study, we empirically study the repetitiveness of the smart contracts via cluster analysis and try to extract the differentiated code from the similar contracts. Differentiated code is defined as the source code except the repeated ones in two similar smart contracts, which usually illustrates how a software feature is implemented or a programming issue is solved. Then, differentiated code might be used to guide the update of a smart contract in its next version. In this paper, to support the update of a target smart contract, we apply syntax and semantic similarities to discover its similar smart contracts from more than 120,000 smart contracts, and recommend the differentiated code to the target smart contract. The promising experimental results demonstrated the differentiated code can effectively support smart contract update.

Program debugging is a time-consuming task, and researchers have proposed different kinds of automatic fault localization techniques to mitigate the burden of manual debugging. Among these techniques, two popular families are spectrum-based fault localization (SBFL) and statistical debugging (SD), both localizing faults by collecting statistical information at runtime. Though the ideas are similar, the two families have been developed independently and their combinations have not been systematically explored. In this paper we perform a systematical empirical study on the combination of SBFL and SD. We first build a unified model of the two techniques, and systematically explore four types of variations, different predicates, different risk evaluation formulas, different granularities of data collection, and different methods of combining suspicious scores. Our study leads to several findings. First, most of the effectiveness of the combined approach contributed by a simple type of predicates: branch conditions. Second, the risk evaluation formulas of SBFL significantly outperform that of SD. Third, fine-grained data collection significantly outperforms coarse-grained data collection with a little extra execution overhead. Fourth, a linear combination of SBFL and SD predicates outperforms both individual approaches. According to our empirical study, we propose a new fault localization approach, PREDFL (Predicate-based Fault Localization), with the best configuration for each dimension under the unified model. Then, we explore its complementarity to existing techniques by integrating PREDFL with a state-of-the-art fault localization framework. The experimental results show that PREDFL can further improve the effectiveness of state-of-the-art fault localization techniques. More concretely, integrating PREDFL results in an up to 20.8% improvement w.r.t the faults successfully located at Top-1, which reveals that PREDFL complements existing techniques.

Comments convey useful information about the system functionalities and many methods for software engineering tasks take comments as an important source for many software engineering tasks such as code semantic analysis, code reuse and so on. However, unlike structural doc comments, it is challenging to identify the relationship between the functional semantics of the code and its corresponding textual descriptions nested inside the code and apply it to automatic analyzing and mining approaches in software engineering tasks efficiently. In this paper, we propose a general method for the detection of source code comment scopes. Based on machine learning, our method utilized features of code snippets and comments to detect the scopes of source code comments automatically in Java programs. On the dataset of comment-statement pairs from 4 popular open source projects, our method achieved a high accuracy of 81.45% in detecting the scopes of comments. Furthermore, the results demonstrated the feasibility and effectiveness of our comment scope detection method on new projects. Moreover, our method was applied to two specific software engineering tasks in our studies: analyzing software repositories for outdated comment detection and mining software repositories for comment generation. As a general approach, our method provided a solution to comment-code mapping. It improved the performance of baseline methods in both tasks, which demonstrated that our method is conducive to automatic analyzing and mining approaches on software repositories.

Comments which are an integral part of software development improve program comprehension and software maintainability. They convey useful information about the system functionalities and many text retrieval methods for software engineering tasks take comments as an important source for code semantic analysis. However, it is challenging to identify the relationship between the functional semantics of the code and its corresponding textual descriptions and apply it to automatic mining approaches in software engineering efficiently. In this paper, we use machine learning which utilizes features of code snippets and comments to detect the scopes of source code comments automatically in Java programs. Based on the dataset of comment-statement pairs from 4 popular open source projects, our method achieved a high accuracy of 81.15% in detecting the scopes of comments. Furthermore, the experimental results demonstrated the feasibility and effectiveness of our comment scope detection method.

Comments are used as standard practice in software development to increase the readability of code and to express programmers' intentions in a more explicit manner. Nevertheless, keeping comments up-to-date is often neglected for programmers. In this paper, we proposed a machine learning based method for detecting the comments that should be changed during code changes. We utilized 64 features, taking the code before and after changes, comments and the relationship between the code and comments into account. Experimental results show that 74.6% of outdated comments can be detected using our method, and 77.2% of our detected outdated comments are real comments which require to be updated. In addition, the experimental results indicate that our model can help developers to discover outdated comments in historical versions of existing projects.

Code review involves a significant amount of human effort to understand the code change, because the information required to inspect code changes may distribute across multiple files that reviewers are not familiar with. Code changes are often organized as commits for review. In this paper, we found that most of the commits contain a salient class, which is saliently modified and causes the modification of the rest classes in a commit. Our user studies confirmed that identifying the salient class in a commit can facilitate reviewers in understanding code change. We model the salient class identification as a binary classification problem and extract a number of discriminative features from commit to characterize the salience of a class. The initial experiment result shows that the proposed approach can improve the efficiency of reviewers understanding code changes in code review.

Commit comments increasingly receive attention as an important complementary component in code change comprehension. To address the comment scarcity issue, a variety of automatic approaches for commit comment generation have been intensively proposed. However, most of these approaches mechanically outline a superficial level summary of the changed software entities, the change intent behind the code changes is lost (e.g., the existing approaches cannot generate such comment: "fixing null pointer exception"). Considering the comments written by developers often describe the intent behind the code change, we propose a method to automatically generate commit comment by reusing the existing comments in version control system. Specifically, for an input commit, we apply syntax, semantic, pre-syntax, and pre-semantic similarities to discover the similar commits from half a million commits, and recommend the reusable comments to the input commit from the ones of the similar commits. We evaluate our approach on 7 projects. The results show that 9.1% of the generated comments are good, 27.7% of the generated comments need minor fix, and 63.2% are bad, and we also analyze the reasons that make a comment available or unavailable.

Developers often bundle unrelated changes (eg, bug fix and feature addition) in a single commit and then submit a “poor cohesive” commit to version control system. Such a commit consists of multiple independent code changes and makes review of code changes harder. If the code changes before commit can be identified as related and unrelated ones, the “cohesiveness” of a commit can be guaranteed. Inspired by the effectiveness of machine learning techniques in classification field, we model the relevance identification of code changes as a binary classification problem (ie, related and unrelated changes) and propose discriminative feature in software entities to characterize the relevance of code changes. In particular, to quantify the discriminative feature, 21 coupling rules and 4 cochanged type relationships are elaborately extracted from software entities to construct related changes vector (RCV). Twenty-one coupling rules at granularities of class, attribute, and method can capture the relevance of code changes from structural coupling dimension, and 4 cochanged type relationships are defined to capture the change type combinations of software entities that may cause related changes. Based on RCV, machine learning algorithms are applied to identify the relevance of code changes. The experiment results show that probabilistic neural network and general regression neural network provide statistically significant improvements in accuracy of relevance identification of code changes over the other 4 machine learning algorithms. Related changes vector with 72 dimensions (RCV72) outperforms other 2RCVs with less dimensions.

UI is an important part of software product.Considering the complexity of web UI, generating the web page from a mockup proposes requirements for rich experience of developer.Extracting visible elements and their relationship, selecting proper tags, generating source code are time-consuming and error-prone task.In this paper, we propose a method to automate the transforming of the mockup to the web page.Our approach starts from the mockup designed by the art designers, and extracts the elements based on the color features of the edges.Then a bottom-up tag generating method based on the Random Forest is proposed to select the tags for elements.Finally the web page is generated by the definition of the elements.The generating tags can achieve an average accuracy of more than 84%, which can meet the basic requirements of the developers.

Compared to traditional education resource, Interactive Education Resource (IER) includes dynamic content to interact with users in order to enhance comprehension.The contents of IERs are relatively complex because of its dynamic feature.Exploring IERs and understanding its content during resource search become time-consuming.In this paper, we propose a preview generation approach based on automated software testing and image processing.Our approach first analyzes IERs to collect interactive elements and the event list.Based on the interaction related information, our approach simulates user actions and record snapshots step by step.Our approach compares snapshots to generate an image including the basic content, interaction region and dynamic contents.The image is used as the overall preview and the animation of snapshots collected during simulation is used as detail preview of the IER.In the experiment, we evaluate the completeness, correctness, and comprehension of the preview.The experiment result shows that the preview can be used to provide most information in the resource correctly and easy to understand.Our approach can save time for users in understanding the IERs.

The complexity of mobile applications often lies in the user interface (UI).To update function provided by UI or just fix bugs related to UI, software maintainers primarily need to obtain the location of source code implementation and detect change set.Since UI related feature is tightly related to the class containing the declaration of the UI component, this paper proposes a topic matching based change impact analysis method from feature on user interface of mobile apps.Our approach combines LDA model with program dependency to realize the change impact analysis.Considering app ′ s small scale and few comments, a novel preprocessing method combining tf-idf with term weight based on structural information is applied to LDA model.Experiments on 16 update records of 4 open source apps show the effectiveness of our proposed method.

Current softwares are continuously updating. The change between two versions usually involves multiple program entities (e.g., Class, method, attribute) with multiple purposes (e.g., Changed requirements, bug fixing). It's hard for developers to understand which changes are made for the same purpose. However, whether two changes are related is not decided by the relationship between this two entities in the program. In this paper, we summarize 4 coupling rules (16 instances) and 4 co-changed types at class, method and attribute levels for software change. We propose the Related Change Vector (RCV) to characterize the related changes, which is defined based on the coupling rules and co-changed types. Probabilistic neural network is used to detect related software changes with RCV as input. Our approach is evaluated with experiments on 3 software projects (14 versions) written in Java. The results indicate that the average detection precision is about 90%.

Monitoring functionality is implemented and provided as infrastructure of most software platforms and applications. However, the construction of system model cannot be achieved by directly composing runtime model of different applications. First, models which conform to different meta-models cannot be directly composed. Second, the abstract of a system may be different from different viewpoint. Finally, the relationships between systems are different from different abstract viewpoint. In this paper, we propose a DSL (Domain Specific Language) for composition of monitoring components. The DSL distinguish component definition and instance clearly in order to enables reuse of monitoring component. Based on the component composition, the meta-model of target runtime model is generated. We developed an algorithm to generate model transformation for synthesizing runtime models of its applications. In the case study, we choose four monitoring systems as monitoring component types in our DSL. We introduce how to compose monitoring components for on-demand construction of runtime model based on model synthesis.

With the increasing maturity of model-driven tools and methods, new model-based analysis methods are developed to support specific stakeholder concerns during software lifecycle. This multiplication of models and their related analysis tools calls for solution addressing the integration of MOF-based analysis methods. Current research works on integration of analysis methods have already addressed the extraction of the needed input data as well as the control and the integration of the tools supporting the analysis execution. However, little attention has been paid to the integration of analysis results back into initial model. We propose a MOF-based framework enabling the integration of analysis results that a) defines a meta-model capturing the integration requirements, b) provides a MOF meta-model extension mechanism with support for upward compatibility; and c) automatically generates a model transformation for model integration. We illustrate the use of our framework by integrating a reliability analysis methods and a fault tolerant reconfiguration method on the ABC/ADL Software Architecture. We applied the resulting analysis composition onto the ECPerf JEE system.

The differentiated service approach has been proposed as a potential solution to provide quality of service (QoS) in the next generation Internet. The ultimate goal of end-to-end service differentiation can be achieved by complementing the network-level QoS with service differentiation at Internet servers. In this paper, we have presented a detailed study of the performance of service differentiating Web servers (SDIS). Various aspects, such as admission control, scheduling, and task assignment schemes for SDIS, have been evaluated through real workload traces. The impact of these aspects has been quantified in a simulation-based study. Under high system utilization, a service differentiating server provides significantly better services to high priority tasks compared to a traditional Internet server. A combination of selective early discard and priority-based task scheduling and assignment is required to provide efficient service differentiation at the servers. The results of these studies could be used as a foundation for further studies on service differentiating Internet servers.

The diversity in web object types and their resource requirements contributes to the unpredictability of web service provisioning. In this paper, an efficient admission control algorithm, PACERS, is proposed to provide different levels of services based on the server workload characteristics. Service quality is ensured by periodical allocation of system resources based on the estimation of request rate and service requirements of prioritized tasks. Admission of lower priority tasks is restricted during high load periods to prevent denial-of-services to high priority tasks. A double-queue structure is implemented to reduce the effects of estimation inaccuracy and to utilize the spare capacity of the server, thus increasing the system throughput. Response delays of the high priority tasks are bounded by the length of the prediction period. Theoretical analysis and experimental study show that the PACERS algorithm provides desirable throughput and bounded response delay to the prioritized tasks, without any significant impact on the aggregate throughput of the system under various workload.

Differentiated service has been proposed as a potential solution for bandwidth allocation and is expected to be supported in the next-generation Internet. However, a service-differentiating Internet with best-effort servers may not meet the overall goals of the differentiated service. In this paper, approaches and performance issues on providing differentiated services from an Internet server are studied. Experimental study and analyses prove that under near-saturation of server utilization, differentiating service provides significantly better performance to high priority tasks compared to a traditional service mode. Quantitative performance estimation of different priority levels of tasks is presented. It is also observed that an enhanced shortest queue first task assignment scheme helps in decreasing the average response time of the server system.

In generative, constraint-based design, users graphically select shape elements of design instances in order to specify shape operations that have generic intent. We discuss techniques for naming algorithmically and generically the identified geometric instance, and report on our experience with implementing these techniques. In a companion paper, we give algorithms for matching the names when editing designs.

Abstract A concise, complete and reliable algorithm for triangulating an arbitrary polygon is presented as a powerful core processor of PLAN‐I (Production Layout Automation Nucleus) system1. A polygon with inner loops is converted into a non‐self‐intersecting polygon (NIP) through adding‘Bridge Edges'. A triangular splitting algorithm for NIP is described in detail and successfully implemented. The program is about 300 lines in FORTRAN‐77. Sweeping and local operations with respect to the triangular‐faceted boundary representation are designed with the algorithm to improve functions of solid modeling in PLAN‐I. The algorithm of triangulation can also be applied to Boolean operations and other issues.