Source Code Quality Research Articles

Handover of managerial responsibilities in global software development: a case study of source code evolution and quality

Studies report on the negative effect on quality in global software development (GSD) due to communication and coordination-related challenges. However, empirical studies reporting on the magnitude of the effect are scarce. This paper presents findings from an embedded explanatory case study on the change in quality over time, across multiple releases, for products that were developed in a GSD setting. The GSD setting involved periods of distributed development between geographically dispersed sites as well as a handover of project management responsibilities between the involved sites. Investigations were performed on two medium-sized products from a company that is part of a large multinational corporation. Quality is investigated quantitatively using defect data and measures that quantify two source code properties, size and complexity. Observations were triangulated with subjective views from company representatives. There were no observable indications that the distribution of work or handover of project management responsibilities had an impact on quality on both products. Among the product-, process- and people-related success factors, we identified well-designed product architectures, early handover planning and support from the sending site to the receiving site after the handover and skilled employees at the involved sites. Overall, these results can be useful input for decision-makers who are considering distributing development work between globally dispersed sites or handing over project management responsibilities from one site to another. Moreover, our study shows that analyzing the evolution of size and complexity properties of a product’s source code can provide valuable information to support decision-making during similar projects. Finally, the strategy used by the company to relocate responsibilities can also be considered as an alternative for software transfers, which have been linked with a decline in efficiency, productivity and quality.

CONTINUITY OF DEVELOPER RANKING AND GROWTH CHANGE PREDICTION

Enormous amounts of raw content and information exist universally and large databases contain unordered, ungraded and unranked data. Ranking is most famous, ubiquitous and comprehensive techniques to build hierarchy of unordered group of items by calculating rank of every item based on one or several multiple attributes values. This technique allows analyzing and evaluating product performance with other products. Widespread usage of ranking technique represents relationship among several groups of well known items. In this analysis paper, We retrieve promising information from Git repository and demonstrate important fact of developers working individually or in a group and rank the developers based on core activities and contribution on several projects, bug resolving processes, source code commit and expertise in multiple languages by mining Git (a version control repository system). We discover key developers, influential software practitioner, projects and programming languages. We found developers grow over time in diverse areas. Our result shows developer ranking can assists project manager to take better quality decision to assign projects and gain help from expertise developer to support newly joined team members in the organization. Ranked developer can assists business to improve source code quality, timely delivery of projects, lower maintenance cost and better customer satisfaction. Keyword software practitioners, ranking, developers, Language-Language, commits ----------------------------------------------------------------------***--------------------------------------------------------------------

Studying the relationship between source code quality and mobile platform dependence

The recent meteoric rise in the use of smartphones and other mobile devices has led to a new class of software applications (i.e., mobile apps). One reason for this success is the extensive support available to mobile app developers through the APIs provided by mobile platforms (e.g., Android). In our previous research, we found that mobile apps tend to depend highly on these platform-specific APIs. High dependence on a particular mobile platform may introduce instability and defects, as these mobile platforms are rapidly evolving. Therefore, the extent of platform dependence may be an indicator of software quality. In this paper, we examine the relationship between platform dependence and defect proneness of the source code files of an Android app to determine whether software metrics based on platform dependence can be used to prioritize software quality assurance efforts. We find that (1) source code files that are defect prone have a higher dependence on the platform than defect-free files and (2) increasing the platform dependence increases the likelihood of a defect being present in a source code file. Thus, platform dependence may be used to prioritize the most defect-prone source code files for code reviews and unit testing by the software quality assurance team.

SMSCQA: System for Measuring Source Code Quality Assurance

software systems play a critical role in various aspects of human life, and become part of everyday life. Many of these systems are essential for the completion of day-to-day activities. The increased reliance on computer applications, and organization that produced software puts more and more strain on software developers and software systems itself. For these reasons many international standards, requirements, and constrains were established to assure quality of software. In this work the most important fundamentals of software quality assurance used during life cycle development process (LCDP) will be covered. Specially that used in coding phase. This phase is a very important period for all software, because the cure of software system will be established here. Therefore it was sliced in detailes, and all of its aspects were recovered like: Software metrics, Software quality factors, and software quality models like McCall's model, Boehm's model, ISO 9126 model, and SATC NASA model. By comparing and studying these models the System for Measuring Source Code Quality Assurance was retrieved. Using this system over 30 source code metrics, 9 quality factors can be measured and overall quality might be calculated.

Software defect prediction using Bayesian networks

There are lots of different software metrics discovered and used for defect prediction in the literature. Instead of dealing with so many metrics, it would be practical and easy if we could determine the set of metrics that are most important and focus on them more to predict defectiveness. We use Bayesian networks to determine the probabilistic influential relationships among software metrics and defect proneness. In addition to the metrics used in Promise data repository, we define two more metrics, i.e. NOD for the number of developers and LOCQ for the source code quality. We extract these metrics by inspecting the source code repositories of the selected Promise data repository data sets. At the end of our modeling, we learn the marginal defect proneness probability of the whole software system, the set of most effective metrics, and the influential relationships among metrics and defectiveness. Our experiments on nine open source Promise data repository data sets show that response for class (RFC), lines of code (LOC), and lack of coding quality (LOCQ) are the most effective metrics whereas coupling between objects (CBO), weighted method per class (WMC), and lack of cohesion of methods (LCOM) are less effective metrics on defect proneness. Furthermore, number of children (NOC) and depth of inheritance tree (DIT) have very limited effect and are untrustworthy. On the other hand, based on the experiments on Poi, Tomcat, and Xalan data sets, we observe that there is a positive correlation between the number of developers (NOD) and the level of defectiveness. However, further investigation involving a greater number of projects is needed to confirm our findings.

Code Quality Evaluation Methodology Using The ISO/IEC 9126 Standard

This work proposes a methodology for source code quality and static behaviour evaluation of a software system, based on the standard ISO/IEC-9126. It uses elements automatically derived from source code enhanced with expert knowledge in the form of quality characteristic rankings, allowing software engineers to assign weights to source code attributes. It is flexible in terms of the set of metrics and source code attributes employed, even in terms of the ISO/IEC-9126 characteristics to be assessed. We applied the methodology to two case studies, involving five open source and one proprietary system. Results demonstrated that the methodology can capture software quality trends and express expert perceptions concerning system quality in a quantitative and systematic manner.

Improving the usability of the source code quality index with interchangeable metrics sets

The aim of this research is to improve the usability and acceptance of the quality index in practice. The quality index (QI) that is used to calculate acknowledged project effort is empirically evaluated in order to find interchangeable metric sets that can be used when calculating QI. In the evaluation, ten metric sets with four metrics in the set were used to calculate ten different quality indexes that were then evaluated on 25 projects. The results indicate that six metric sets are interchangeable, making the calculation of the QI easy.

The EMISQ method and its tool support-expert-based evaluation of internal software quality

There is empirical evidence that internal software quality, e.g., the quality of source code, has great impact on the overall quality of software. Besides well-known manual inspection and review techniques for source code, more recent approaches utilize tool-based static code analysis for the evaluation of internal software quality. Despite the high potential of code analyzers the application of tools alone cannot replace well-founded expert opinion. Knowledge, experience and fair judgment are indispensable for a valid, reliable quality assessment, which is accepted by software developers and managers. The EMISQ method (Evaluation Method for Internal Software Quality), guides the assessment process for all stakeholders of an evaluation project. The method is supported by the Software Product Quality Reporter (SPQR), a tool which assists evaluators with their analysis and rating tasks and provides support for generating code quality reports. The application of SPQR has already proved its usefulness in various code assessment projects around the world. This paper introduces the EMISQ method and describes the tool support needed for an efficient and effective evaluation of internal software quality.

Agile Quality Assessment for Program Source Code : Application of the "Quality Inspection" to Program Source Code Quality Assessment(<Special Issue>New movement of Project Management)

Agile Quality Assessment for Program Source Code : Application of the "Quality Inspection" to Program Source Code Quality Assessment(<Special Issue>New movement of Project Management)

임베디드 소프트웨어의 소스 코드 품질 향상을 위한 Practice Patterns의 적용

임베디드 소프트웨어는 하드웨어 플랫폼에 탑재하기 전, 소스 코드에 대한 품질을 검증하는 작업이 매우 중요하다. 임베디드 소프트웨어의 코드 품질을 향상시키기 위해서는 분석 및 설계 단계의 모델에 대한 품질과 생성된 코드에 대한 품질이 관리되어야 한다. 본 연구에서는 임베디드 소프트웨어의 소스 코드 품질을 향상시키기 위한 방법으로 Practice Pattern을 제안한다. 이는 모델링 과정이나 코딩 과정에서 개발자를 가이드 하는 절차 패턴으로써, 모델의 품질과 소스 코드 품질을 향상시키는 방법으로 사용될 수 있다. 제시하는 패턴의 적용은 기능의 정확성뿐만 아니라 성능, 모듈화, 재사용성 및 이식성 등과 같은 품질 요소들을 향상시킬 수 있을 것으로 보인다. Source code quality is very Important that software embedded into product is difficult to change. In order to improve source code quality, it should be considered the quality of analysis and design models as well as the quality of source code. In this paper, we suggest 'Practice Pattern' as one of practical techniques to improve embedded software source code quality. Practice pattern is a procedural pattern to guide modeling and coding activities in software development phases. We believe that applying our pattern provides the improvement of optimum performance, modularization, and portability for embedded software source code.

Surfing the net for software engineering notes

What is good code? A simple question, but how can you tell if a load o' code is good stuff or a pile of spaghetti? That's where source code quality analysis comes into play. In this month's column, we're going to visit some web sites that will help you establish or improve your code quality processes.

SOFTWARE SOURCE CODE: A QUALITY ASSURANCE MEASUREMENT SYSTEM

Today software systems play a critical role in various aspects of human life, from rockets to health care, and become part of everyday life. Many of these systems are relied upon as being essential for the completion of day-to-day activities. The increased reliance on computer applications, and organizations that produce software puts more and more strain on software developers to produce high quality systems. For these reasons many international standards, requirements, and constrains were established to assure quality of software. This paper introduces a new software Source Code Quality Assurance Measurement System named SCQAM. In addition, it presents some of the most important software quality assurance fundamentals used during the different phases of software development life cycle. Particularly, the focus of this paper is bounded to the coding phase, where in this phase the cure of software system will be established. Therefore, the scope of this paper covers most of the related aspects of software quality assurance of the coding phase including: software metrics, software quality factors, and software quality models like McCall's model, Boehm's model, ISO 9126 model, and SATC NASA model. As a result of analyzing these models, the proposed system was designed, developed, and tested. The proposed SCQAM can measure over 30-source code metrics, then group these metrics to compute nine distinct quality factors and indicators, then an overall quality indicator of the input source code is calculated. The experimental results show the superiority of the SCQAM system over Project Analyzer, another quality assurance measurement system, specifically in the area of source code quality measurement.

Predicting source-code complexity at the design stage

It is shown how metrics can be used to gauge the quality of source code by evaluating its design specifications before coding, thus shortening the development life cycle. The predictive abilities of several types of metrics, all quantitative, are evaluated, and statistics that can be used to adapt them to a particular project are provided. The study data consist of programs written by students, but, because the programs are large, the professor did not provide the specifications, and the test data were not provided, it is believed that the programs are sufficiently realistic for the approach presented to be generally valid. >