Source Code Changes Research Articles

Development of partial least squares regression with discriminant analysis for software bug prediction

Many prediction models and approaches have been introduced during the past decades that try to forecast bugged code elements based on static source code metrics, change and history metrics, or both. However, there is still no universal best solution to this problem, as most suitable features and models vary from dataset to dataset and depend on the context in which we use them. Therefore, novel approaches and further studies on this topic are highly necessary.In this paper, we employ a chemometric approach – Partial Least Squares with Discriminant Analysis (PLS-DA) – for predicting bug prone Classes in Java programs using static source code metrics. PLS-DA is successfully applied within the field of chemometrics, but to our best knowledge, it has never been used before in the software maintenance domain for predicting bugs. In addition, we have used rigorous statistical treatments and evaluation for representing the software engineering results.We show that our PLS-DA based prediction model achieves superior performances compared to the state-of-the-art approaches (i.e. F-measure of 0.44–0.47 at 90% confidence level) when no data re-sampling applied and comparable to others when applying up-sampling on the largest open bug dataset, while training the model is significantly faster, thus finding optimal parameters is much easier. In terms of completeness, which measures the amount of bugs contained in the Java Classes predicted to be defective, PLS-DA outperforms every other algorithm: it found 69.3% and 79.4% of the total bugs with no re-sampling and up-sampling, respectively.

Terrain-Aware Military Planning Agents

Terrain is important, often decisive, in military battles. This concept recurs across numerous historical examples, military theorists, and doctrinal manuals used by armies around the world. This poster discusses how Mission Command Agents, automated agents used to represent the behaviors of military forces in combat simulations, achieve this understanding of the importance of terrain. First, a review of tactical manuals from different nations consistently identified the importance of terrain to observation, fires, and mobility. Based on the unit’s mission, the geography afforded, or prevented, these activities with respect to the enemy force. The next step was to build an automated tool that could quickly calculate these effects based on the anticipated positions. The third step was to formulate these quantifiable terrain effects as objectives in a multi-objective search heuristic so that different places could be compared with each other. After excellent results with these techniques in a realistic military planning scenario, the team is further enhancing human-machine collaboration in this area by adding geospatial and military characteristics of terrain to an existing standard for Command and Control – Simulation Interoperation (C2SIM). With this enhancement, the reasoning employed by the agents is more explainable to military observers. It also allows military experts to adjust agent behaviors by adjusting their goals, without the need to change source code, while employing a user interface that they will be familiar with.

Regression test prioritization leveraging source code similarity with tree kernels

AbstractRegression test prioritization (RTP) is an active research field, aiming at re‐ordering the tests in a test suite to maximize the rate at which faults are detected. A number of RTP strategies have been proposed, leveraging different factors to reorder tests. Some techniques include an analysis of changed source code, to assign higher priority to tests stressing modified parts of the codebase. Still, most of these change‐based solutions focus on simple text‐level comparisons among versions. We believe that measuring source code changes in a more refined way, capable of discriminating between mere textual changes (e.g., renaming of a local variable) and more structural changes (e.g., changes in the control flow), could lead to significant benefits in RTP, under the assumption that major structural changes are also more likely to introduce faults. To this end, we propose two novel RTP techniques that leverage tree kernels (TK), a class of similarity functions largely used in Natural Language Processing on tree‐structured data. In particular, we apply TKs to abstract syntax trees of source code, to more precisely quantify the extent of structural changes in the source code, and prioritize tests accordingly. We assessed the effectiveness of the proposals by conducting an empirical study on five real‐world Java projects, also used in a number of RTP‐related papers. We automatically generated, for each considered pair of software versions (i.e., old version, new version) in the evolution of the involved projects, 100 variations with artificially injected faults, leading to over 5k different software evolution scenarios overall. We compared the proposed prioritization approaches against well‐known prioritization techniques, evaluating both their effectiveness and their execution times. Our findings show that leveraging more refined code change analysis techniques to quantify the extent of changes in source code can lead to relevant improvements in prioritization effectiveness, while typically introducing negligible overheads due to their execution.

Explicit Effects and Effect Constraints in ReML

An important aspect of building robust systems that execute on dedicated hardware and perhaps in constrained environments is to control and manage the effects performed by program code. We present ReML, a higher-order statically-typed functional language, which allows programmers to be explicit about the effects performed by program code and in particular effects related to memory management. Allowing programmers to be explicit about effects, the regions in which values reside, and the constraints under which code execute, makes programs robust to changes in the program source code and to compiler updates, including compiler optimisations. ReML is integrated with a polymorphic inference system that builds on top of region-inference, as it is implemented in the MLKit, a Standard ML compiler that uses region-based memory management as its primary memory management scheme.

Multi-grained contextual code representation learning for commit message generation

Commit messages, precisely describing the code changes for each commit in natural language, makes it possible for developers and succeeding reviewers to understand the code changes without digging into implementation details. However, the semantic and structural gap between code and natural language poses a significant challenge for commit message generation. Several researchers have proposed automated techniques to generate commit messages. Nevertheless, the information about the code is not sufficiently exploited. In this paper, we propose multi-grained contextual code representation learning for commit message generation (COMU). We extract multi-grained information from the changed code at the line and AST levels (i.e., Code_Diff and AST_Diff). In Code_Diff, we construct global contextual semantic information about the changed code, and mark whether a line of code has changed with three different tokens. In AST_Diff, we extract the code structure from source code changes and combine the extracted structure with four types of editing operations to explicitly focus on the detailed information of the changed part. In addition, we build the experimental datasets, since there is still no publicly sufficient dataset for this task. The release of this dataset would contribute to advancing research in this field. We perform an extensive experiment to evaluate the effectiveness of COMU. The experimental evaluation and human study show that our model outperforms the baseline model.

Revealing code change propagation channels by evolution history mining

Changes on source code may propagate to distant code entities through various kinds of relationships, which may form up change propagation channels. It is however difficult for developers to reveal code change propagate channels due to sophisticated interrelationships among code entities. In this work, we propose a novel graph representation for the changed code entities and related code entities changed within a range of space and time so that the types of relationships along which the changes are propagated can be explicitly presented. Then a subgraph mining technique is used to find the frequent change propagation channels.We finally reveal 40 types of frequent change propagation channels that cover over 98% cases of code change propagation in five well-known open-source Java projects. We find evidence that the code changes propagated through an unchanged intermediate code entity consume more time than those through a changed one, indicating the difficulties in maintaining code entities that related through indirect relationships. We find that a small proportion of code entities frequently appear in the FCPCs, and confirm the semantic relationships between code entities covered by 50 instances of FCPCs, indicating potential usefulness for developers to explain the range of change impact from given source code changes.

Studying the Co-Evolution of Source Code and Acceptance Tests

Testing is a vital part of achieving good-quality software. Deploying untested code can cause system crashes and unexpected behavior. To reduce these problems, testing should evolve with coding. In addition, test suites should not remain static throughout the software versions. Since whenever software gets updated, new functionalities are added, or existing functionalities are changed, test suites should be updated along with the software. Software repositories contain valuable information about the software systems. Access to older versions and differentiating adjacent versions’ source code and acceptance test changes can provide information about the evolution process of the software. This research proposes a method and implementation to analyze 21 open-source real-world projects hosted on GitHub regarding the co-evolution of both software and its acceptance test suites. Related projects are retrieved from repositories, their versions are analyzed, graphs are created, and analysis related to the co-evolution process is performed. Observations show that the source code is getting updated more frequently than the acceptance tests. They indicate a pattern that source code and acceptance tests do not evolve together. Moreover, the analysis showed that a few acceptance tests test most of the functionalities that take a significant line of code.

An Automated Framework for Detecting Change in the Source Code and Test Case Change Recommendation

Improvements and acceleration in software development have contributed towards high-quality services in all domains and all fields of industry, causing increasing demands for high-quality software developments. The industry is adopting human resources with high skills, advanced methodologies, and technologies to match the high-quality software development demands to accelerate the development life cycle. In the software development life cycle, one of the biggest challenges is the change management between the version of the source codes. Various reasons, such as changing the requirements or adapting available updates or technological upgrades, can cause the source code's version. The change management affects the correctness of the software service's release and the number of test cases. It is often observed that the development life cycle is delayed due to a lack of proper version control and due to repetitive testing iterations. Hence the demand for better version control-driven test case reduction methods cannot be ignored. The parallel research attempts propose several version control mechanisms. Nevertheless, most version controls are criticized for not contributing toward the test case generation of reduction. Henceforth, this work proposes a novel probabilistic rule-based test case reduction method to simplify the software development's testing and version control mechanism. Software developers highly adopt the refactoring process for making efficient changes such as code structure and functionality or applying changes in the requirements. This work demonstrates very high accuracy for change detection and management. This results in higher accuracy for test case reductions. The outcome of this work is to reduce the development time for the software to make the software development industry a better and more efficient world.

Problem issues of identification management of digital objects of multiservice systems

The paper considers the issues of access to the ecosystem of services, obtaining and providing services, which can be both internal and external in relation to the information system in which the digital object is located. Today, the management of relationships between digital objects and services is carried out not only due to the functionality provided by the information system, but also, in particular, due to the management of the identification of digital objects and services. As a digital object, not only the object that wants to receive or provide services, but also the service itself is considered. Therefore, identity management is considered in relation to two interacting objects. The analysis of digital object identification management was carried out based on the following circumstances. Identification of the same digital objects can be expressed in different sign and meaning systems. Therefore, it is necessary to update and maintain many identifiers within one ecosystem of services and be able to manage them. Identifiers can be divided into "stupid" (limited), which cannot perform anything except the function of linking a digital object to a strictly limited set of operations within the information system, regardless of the conditions in which it is located, and "smart", which can provide an opportunity to respond to circumstances and the possibility of implementing a flexible scenario selection that can be updated according to the situation. "Smart" identifiers, unlike "stupid" ones, have properties that allow them to respond to circumstances, and therefore it is necessary to be able to manage such properties of identifiers. The principles of a new architecture for the design of computer systems are proposed, which allow flexible management of digital objects, their properties, identification of digital objects, properties of identifiers depending on the circumstances of the time, place and situation in which the digital objects are located. The new architecture makes it possible to integrate new entities into information systems without significant modernizations associated with changes in source and object code, information schemes of systems, modernization of data structures, which lead to the need for mandatory restructuring of database tables and database table management procedures data.

FS3change: A Scalable Method for Change Pattern Mining

Mining change patterns can give unique understanding on the evolution of dynamically changing systems like social relation graphs, weblinks, hardware descriptions and models. A more recent focus is source code change pattern mining that may qualitatively justify expected or uncover unexpected patterns. These patterns then offer a basis, e.g., for program language evolution or auto-completion support. We present a change pattern mining method that greatly expands the limits of input data and pattern complexity, over existing methods. We propose scalability solutions on conceptual and algorithmic level, thereby evolving the state-of-the-art sampling-based frequent subgraph mining method FS <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">3</sup> , resulting in 75% reduction in memory consumption and a speedup of 6500 for a large scale dataset. Patterns can have 100,000s of occurrences for which manual review is impossible and may lead to misinterpretation. We propose the novel content track approach for interactively exploring pattern contents in context, based on marginal distributions. We evaluate our approach by mining 1,000 open source projects contributing a total of 558 million changes and 2 billion contextual connections among them, thereby, demonstrating its scalability. A manual interpretation of 19 patterns shows sensible mined patterns allowing to deduct implications for language design and demonstrating the soundness of the approach.

Open-source software product line extraction processes: the ArgoUML-SPL and Phaser cases

Software Product Lines (SPLs) are rarely developed from scratch. Commonly, they emerge from one product when there is a need to create tailored variants, or from existing variants created in an ad-hoc way once their separated maintenance and evolution become challenging. Despite the vast literature about re-engineering systems into SPLs and related technical approaches, there is a lack of detailed analysis of the process itself and the effort involved. In this paper, we provide and analyze empirical data of the extraction processes of two open-source case studies, namely ArgoUML and Phaser. Both cases emerged from the transition of a monolithic system into an SPL. The analysis relies on information mined from the version control history of their respective source-code repositories and the discussion with developers that took part in the process. Unlike previous works that focused mostly on the structural results of the final SPL, the contribution of this study is an in-depth characterization of the processes. With this work, we aimed at providing a deeper understanding of the strategies for SPL extraction and their implications. Our results indicate that the source code changes can range from almost a fourth to over half of the total lines of code. Developers may or may not use branching strategies for feature extraction. Additionally, the problems faced during the extraction process may be due to lack of tool support, complexity on managing feature dependencies and issues with feature constraints. We made publicly available the datasets and the analysis scripts of both case studies to be used as a baseline for extractive SPL adoption research and practice.

Performance Enhancement of APW+lo Calculations by Simplest Separation of Concerns

Full-potential linearized augmented plane wave (LAPW) and APW plus local orbital (APW+lo) codes differ widely in both their user interfaces and in capabilities for calculations and analysis beyond their common central task of all-electron solution of the Kohn–Sham equations. However, that common central task opens a possible route to performance enhancement, namely to offload the basic LAPW/APW+lo algorithms to a library optimized purely for that purpose. To explore that opportunity, we have interfaced the Exciting-Plus (“EP”) LAPW/APW+lo DFT code with the highly optimized SIRIUS multi-functional DFT package. This simplest realization of the separation of concerns approach yields substantial performance over the base EP code via additional task parallelism without significant change in the EP source code or user interface. We provide benchmarks of the interfaced code against the original EP using small bulk systems, and demonstrate performance on a spin-crossover molecule and magnetic molecule that are of size and complexity at the margins of the capability of the EP code itself.

Leveraging structural properties of source code graphs for just-in-time bug prediction

The most common use of data visualization is to minimize the complexity for proper understanding. A graph is one of the most commonly used representations for understanding relational data. It produces a simplified representation of data that is challenging to comprehend if kept in a textual format. In this study, we propose a methodology to utilize the relational properties of source code in the form of a graph to identify Just-in-Time (JIT) bug prediction in software systems during different revisions of software evolution and maintenance. We presented a method to convert the source codes of commit patches to equivalent graph representations and named it Source Code Graph (SCG). To understand and compare multiple source code graphs, we extracted several structural properties of these .graphs, such as the density, number of cycles, nodes, edges, etc. We then utilized the attribute values of those SCGs to visualize and detect buggy software commits. We process more than 246 K software commits from 12 subject systems in this investigation. Our investigation on these 12 open-source software projects written in C++ and Java programming languages shows that if we combine the features from SCG with conventional features used in similar studies, we will get the increased performance of Machine Learning (ML) based buggy commit detection models. We also find the increase of F1 Scores in predicting buggy and non-buggy commits statistically significant using the Wilcoxon Signed Rank Test. Since SCG-based feature values represent the style or structural properties of source code updates or changes in the software system, it suggests the importance of careful maintenance of source code style or structure for keeping a software system bug-free.

Estimating the potential of program repair search spaces with commit analysis

The most natural method for evaluating program repair systems is to run them on bug datasets, such as Defects4J. Yet, using this evaluation technique on arbitrary real-world programs requires heavy configuration. In this paper, we propose a purely static method to evaluate the potential of the search space of repair approaches. This new method enables researchers and practitioners to encode the search spaces of repair approaches and select potentially useful ones without struggling with tool configuration and execution. We encode the search spaces by specifying the repair strategies they employ. Next, we use the specifications to check whether past commits lie in repair search spaces. For a repair approach, including many human-written past commits in its search space indicates its potential to generate useful patches. We implement our evaluation method in LighteR. LighteR gets a Git repository and outputs a list of commits whose source code changes lie in repair search spaces. We run LighteR on 55,309 commits from the history of 72 Github repositories with and show that LighteR’s precision and recall are 77% and 92%, respectively. Overall, our experiments show that our novel method is both lightweight and effective to study the search space of program repair approaches.

Source code change analysis with deep learning based programming model

Source code change analysis with deep learning based programming model

Technology of autoclassification of changes in the process of multicomponent software development

The paper proposes an automated method of classification of source code changes, which consists of two steps – clustering and comparison of clusters of classes. The currently existing methods of improving component software development are analyzed. Based on the analysis, it was established that the optimal method of increasing the productivity of the analysis of changes is the clustering of these changes. A method is proposed, according to which the distribution of changes by clusters is carried out automatically. Their comparison to classes is carried out by an expert. It is shown that the automation of the distribution of changes by clusters significantly reduces the time of examination of code changes, which makes it possible to use the obtained results to improve the quality of software during the development of complex software complexes. The results obtained in the course of the work provide an idea of possible data clustering algorithms with further analysis of the obtained set of clusters according to their parameters. Also, on the basis of the conducted research, the results of the comparison of the classifications of changes in the software system with open source code, performed using the proposed automated method and manually, are given. It is shown that the task of controlling changes that are undesirable at the current stage of development is solved significantly more effectively using the proposed method compared to a full examination of changes, as it allows identifying changes of classes prohibited at the current stage of development with less time spent. The application of the method in practice allows to improve the quality of the code due to the increase in the efficiency of the process of its examination. Using the approach proposed in the paper, the examination process under time constraints can be built more efficiently by selecting changes of the most important classes of changes. It has been proven that the method works perfectly if the same type of changes are analyzed, and when the changes combine heterogeneous code modifications, the quality of the automated classification deteriorates. The obtained results make it possible to extend the application of this method to other software complexes and systems, provided that differences in data types and their parameters are taken into account.

On the relation between architectural smells and source code changes

AbstractAlthough architectural smells are one of the most studied type of architectural technical debt, their impact on maintenance effort has not been thoroughly investigated. Studying this impact would help to understand how much technical debt interest is being paid due to the existence of architecture smells and how this interest can be calculated. This work is a first attempt to address this issue by investigating the relation between architecture smells and source code changes. Specifically, we study whether thefrequencyandsizeof changes are correlated with the presence of a selected set of architectural smells. We detect architectural smells using the Arcan tool, which detects architectural smells by building a dependency graph of the system analyzed and then looking for the typical structures of the architectural smells. The findings, based on a case study of 31 open‐source Java systems, show that 87% of the analyzed commits present more changes in artifacts with at least one smell, and the likelihood of changing increases with the number of smells. Moreover, there is also evidence to confirm that change frequency increases after the introduction of a smell and that the size of changes is also larger in smelly artifacts. These findings hold true especially in Medium–Large and Large artifacts.

Comparing fine-grained source code changes and code churn for bug prediction - A retrospective

More than two decades ago, researchers started to mine the data stored in software repositories to help software developers in making informed decisions for developing and testing software systems. Bug prediction was one of the most promising and popular research directions that uses the data stored in software repositories to predict the bug-proneness or number of bugs in source files. On that topic and as part of Emanuel's PhD studies, we submitted a paper with the title Comparing fine-grained source code changes and code churn for bug prediction [8] to the 8th Working Conference on Mining Software Engineering, held 2011 in beautiful Honolulu, Hawaii. Ten years later, it got selected as one of the finalists to receive the MSR 2021 Most Influential Paper Award. In the following, we provide a retrospective on our work, describing the road to publishing this paper, its impact in the field of bug prediction, and the road ahead.

A Software-Repair Robot Based on Continual Learning

Software bugs are common and correcting them accounts for a significant part of costs in the software development and maintenance process. This calls for automatic techniques to deal with them. One promising direction towards this goal is gaining repair knowledge from historical bug fixing examples. Retrieving insights from software development history is particularly appealing with the constant progress of machine learning paradigms and skyrocketing `big' bug fixing data generated through Continuous Integration (CI). In this paper, we present R-Hero, a novel software repair bot that applies continual learning to acquire bug fixing strategies from continuous streams of source code changes, implemented for the single development platform Github/Travis CI. We describe R-Hero, our novel system for learning how to fix bugs based on continual training, and we uncover initial successes as well as novel research challenges for the community.

Commit2Vec: Learning Distributed Representations of Code Changes

Deep learning methods have found successful applications in fields like image classification and natural language processing. They have recently been applied to source code analysis too, due to the enormous amount of freely available source code (e.g., from open-source software repositories). In this work, we elaborate upon a state-of-the-art approach for source code representation, which uses information about its syntactic structure, and we extend it to represent source code changes (i.e., commits). We use this representation to tackle an industrial-relevant task: the classification of security-relevant commits. We leverage on transfer learning, a machine learning technique which reuses, or transfers, information learned from previous tasks (commonly called pretext tasks) to tackle a new target task. We assess the impact of using two different pretext tasks, for which abundant labeled data is available, to tackle the classification of security-relevant commits. Our results indicate that representations that exploit the structural information in code syntax outperform token-based representations. Furthermore, we show that pre-training on a small dataset ( $$>10^4$$ samples), but for a pretext task that is closely related to the target task, results in better performance metrics than pre-training on a loosely related pretext task with a very large dataset ( $$>10^6$$ samples).