A Developer Recommendation Method Based on Code Quality

Proceedings of the 29th ACM/IEEE international conference on Automated software engineering - ASE '14, 2014

Change Requests (CRs) are key elements to software maintenance and evolution. Finding the appropriate developer to a CR is crucial for obtaining the lowest, economically feasible, fixing time. Nevertheless, assigning CRs is a laborintensive and time consuming task. In this paper, we present a semi-automated CR assignment approach which combines rule-based and information retrieval techniques. The approach emphasizes the use of contextual information, essential to effective assignments, and puts the development team in control of the assignment rules, toward making its adoption easier. Results of an empirical evaluation showed that the approach is up to 46,5% more accurate than approaches which rely solely on machine learning techniques.

arXiv (Cornell University), 2023

Context: Recent research has used data mining to develop techniques that can guide developers through source code changes. To the best of our knowledge, very few studies have investigated data mining techniques and-or compared their results with other algorithms or a baseline. Objectives: This paper proposes an automatic method for recommending source code changes using four data mining algorithms. We not only use these algorithms to recommend source code changes, but we also conduct an empirical evaluation. Methods: Our investigation includes seven open-source projects from which we extracted source change history at the file level. We used four widely data mining algorithms i.e., Apriori, FP-Growth, Eclat, and Relim to compare the algorithms in terms of performance (Precision, Recall and F-measure) and execution time. Results: Our findings provide empirical evidence that while some Frequent Pattern Mining algorithms, such as Apriori may outperform other algorithms in some cases, the results are not consistent throughout all the software projects, which is more likely due to the nature and characteristics of the studied projects, in particular their change history. Conclusion: Apriori seems appropriate for large-scale projects, whereas

2012 28th IEEE International Conference on Software Maintenance (ICSM), 2012

There is a tremendous wealth of code authorship information available in source code. Motivated with the presence of this information, in a number of open source projects, an approach to recommend expert developers to assist with a software change request (e.g., a bug fixes or feature) is presented. It employs a combination of an information retrieval technique and processing of the source code authorship information. The relevant source code files to the textual description of a change request are first located. The authors listed in the header comments in these files are then analyzed to arrive at a ranked list of the most suitable developers. The approach fundamentally differs from its previously reported counterparts, as it does not require software repository mining. Neither does it require training from past bugs/issues, which is often done with sophisticated techniques such as machine learning, nor mining of source code repositories, i.e., commits. An empirical study to evaluate the effectiveness of the approach on three open source systems, ArgoUML, JEdit, and MuCommander, is reported. Our approach is compared with two representative approaches: 1) using machine learning on past bug reports, and 2) based on commit logs. The presented approach is found to provide recommendation accuracies that are equivalent or better than the two compared approaches. These findings are encouraging, as it opens up a promising and orthogonal possibility of recommending developers without the need of any historical change information.

Proceedings of the 22nd International Conference on Program Comprehension, 2014

The paper presents an approach, namely iMacPro, to recommend developers who are most likely to implement incoming change requests. iMacPro amalgamates the textual similarity between the given change request and source code, change proneness information, authors, and maintainers of a software system. Latent Semantic Indexing (LSI) and a lightweight analysis of source code, and its commits from the software repository, are used. The basic premise of iMacPro is that the authors and maintainers of the relevant source code, which is change prone, to a given change request are most likely to best assist with its resolution. iMacPro unifies these sources in a unique way to perform its task, which was not investigated and reported in the literature previously. An empirical study on three open source systems, Ar-goUML, JabRef , and jEdit, was conducted to assess the effectiveness of iMacPro. A number of change requests from these systems were used in the evaluated benchmark. Recall values for top one, five, and ten recommended developers are reported. Furthermore, a comparative study with a previous approach that uses the source-code authorship information for developer recommendation was performed. Results show that iMacPro could provide recall gains from 30% to 180% over its subjected competitor with statistical significance.

International Journal of Advanced Computer Science and Applications

Improvements and acceleration in software development has contributed towards high quality services in all domains and all fields of industry causing increasing demands for high quality software developments. In order to match with the high-quality software development demands, the software development industry is adopting human resources with high skills, advanced methodologies and technologies for accelerating the development life cycle. In the software development life cycle, one of the biggest challenges is the change management between versions of the source codes. The versing of the source code can be caused by various reasons such as change in the requirements or adaptation of functional update or technological upgradations. The change management does not only affect the correctness of the release for the software service, rather also impact the number of test cases. It is often observed that, the development life cycle is delayed due to lack of proper version control and due to the improver version control, the repetitive testing iterations. Hence the demand for better version control driven test case reduction methods cannot be ignored. A number of version control mechanisms are proposed by the parallel research attempts. Nevertheless, most of the version controls are criticized for not contributing towards the test case generation of reduction. Henceforth, this work proposes a novel probabilistic refactoring detection and rule-based test case reduction method in order to simplify the testing and version control mechanism for the software development. The refactoring process is highly adopted by the software developers for making efficient changes such as code structure, functionality or apply change in the requirements. This work demonstrates a very high accuracy for change detection and management. This results into a higher accuracy for test case reductions. The final outcome of this work is to reduce the development time for the software for making the software development industry a better and efficient world.

International Conferences on Software Engineering and Knowledge Engineering, 2019

The software development workflow typically involves developers executing tasks and manipulating artifacts. When developers receive a new task they typically envision a task context with the artifacts they intend to manipulate based on their past experiences. Given software projects may last several months, accumulating a vast amount of tasks, artifacts and developers, envisioning this initial task context may be difficult and error-prone. Developers have to walk-through months of past experiences or examine the experience of other developers, select similar tasks and then define the initial context. This paper introduces a method that helps developers defining the initial task context by combining interaction information over artifacts with text information of tasks. First, the Method uses the Clustering technique to organize project tasks into similar groups by interaction in artifacts. Then, the Method uses the Natural Language Processing technique to associate a new task with groups of similar tasks by interaction. The evaluation shows that the clustering of similar tasks by interaction produces similar tasks assigned with artifacts that will be edited by new tasks. The association of new tasks with similar groups by interaction indicates correlation between textual similarity and interaction similarity.

Proceedings of the 19th International Conference on Enterprise Information Systems, 2017

Software development has become an essential activity for organizations that increasingly rely on these to manage their business. However, poor software quality reduces customer satisfaction, while high-quality software can reduce repairs and rework by more than 50 percent. Software development is now seen as a collaborative and technology-dependent activity performed by a group of people. For all these reasons, choosing correctly software development members teams can be decisive. Considering this motivation, classifying participants in different profiles can be useful during project management team's formation and tasks distribution. This paper presents a developer modeling approach based on software quality metrics. Quality metrics are dynamically collected. Those metrics compose the developer model. A machine learning-based method is presented. Results show that it is possible to use quality metrics to model developers.

IEEE Transactions on Software Engineering, 2004

Software developers are often faced with modification tasks that involve source which is spread across a code base. Some dependencies between source code, such as those between source code written in different languages, are difficult to determine using existing static and dynamic analyses. To augment existing analyses and to help developers identify relevant source code during a modification task, we have developed an approach that applies data mining techniques to determine change patterns-sets of files that were changed together frequently in the past-from the change history of the code base. Our hypothesis is that the change patterns can be used to recommend potentially relevant source code to a developer performing a modification task. We show that this approach can reveal valuable dependencies by applying the approach to the Eclipse and Mozilla open source projects and by evaluating the predictability and interestingness of the recommendations produced for actual modification tasks on these systems.

Software development processes need to have an integrated environment that fulfills specific developer needs. In this context, this paper describes the modeling approach SAGM ((Similarity for Adaptive Guidance Model) that provides adaptive recursive guidance for software processes, and specifically tailored regarding the profile of developers. A profile is defined from a model of developers, through their roles, their qualifications, and through the relationships between the context of the current activity and the model of the activities. This approach presents a similarity measure that evaluates the similarities between the profiles created from the model of developers and those of the development team involved in the execution of a software process. This is to identify the profiles classification and to deduce the appropriate type of assistance (that can be corrective, constructive or specific) to developers.

Recently frequent and sequential pattern mining algorithms have been widely used in the field of software engineering to mine various source code or specification patterns. In practice software evolves from one version to another is needed for providing extra facilities to user. This kind of task is challenging in this domain since the database is usually updated in all kinds of manners such as insertion, various modifications as well as removal of sequences. If database is optimized then this optimized information will help developer in their development process and save their valuable time as well as development expenses. Some existing algorithms which are used to optimize database but it does not work faster when database is incrementally updated. To overcome this challenges an efficient algorithm is recently introduce, called the Canonical Order Tree that captures the content of the transactions of the database and orders. In this paper we have proposed a technique based on the Canonical Order Tree that can find out frequent patterns from the incremental database with speedy and efficient way. Thus the database will be optimized as well as it gives useful information to recommend software developer.