Testing and Debugging

Early prediction of quality of service using interface-level metrics, code-level metrics, and antipatterns

Software Quality Assurance is a sub-process that ensures that developed software meets and complies with defined or standardized quality specifications. Focusing on source code, there are characteristics that can be used to evaluate the quality. Introductory courses must encourage freshmen students to improve internal quality of their source code, but only as sophomore they have contact with Software Engineering concepts, including Quality Assurance. In this paper we present a tool to source code quality evaluation aimed at supporting students to improve their source code and, consequently, their programming skills. The proposed tool uses quality reports (available to professional environment integrate with software repositories) to analyze students' source code and provide a feedback about the student coding. The proposed tool run locally, with few computational resources. In addition, we proposed the methodology to use the proposed tool: it consists of challenging students to perform a set of maintenance tasks in a controlled environment. We prepared a source code by introducing common defects, what decreases the quality of source code, and ask to students to perform maintenance tasks in order to both eliminate the introduced defects and introduce new features. After each modification, the students must evaluate their code using the proposed tool to obtain a feedback about quality of source code. To evaluate the approach and the tool, we created a survey and applied to students and the teacher. As a result, we show the benefits of using the proposed tool to both teachers and students perspectives. The results are positive to enhance the teaching-learning Software Quality Assurance to Software Engineering students.

Source code quality is undoubtedly very important, yet usually forgotten aspect of software development process. This study shows different approaches to analysis of student codes, mainly in Java. By comparing different widely-used tools and our solution, we are able to get precise results from such an analysis, and thus to improve the code quality. The analysis results can also be used to determine knowledge and skills of novice programmers (students). Analysis of source codes may be as simple as counting the occurrences of language constructs or as complex as design pattern detection. Different approaches and solutions, i.e. measurements of language construct occurrences, copy-pasted code and design pattern detection, or source code quality, are discussed and subjected to evaluation by being executing on source codes of students as novice programmers.

In Engineering and Scientific computing, a significant number of software systems that are being commonly used by the Engineering community are developed and deployed as Open Source Systems (OSS). This collaborative development model has been widely accepted in both academia and industry. As these systems are typically developed by developers who are experts in their fields (e.g., Engineering), some of those programmers may be lacking an essential skillset today's software quality and engineering concepts (e.g., source code maintainability and analyzability, source code vulnerability, parallelization, etc.). An empirical study is presented that examines some of the source code quality aspects and programming practices (e.g., jumps statements, usage of recursion) from software engineering perspective in ten open source Engineering software systems. The studied systems are written in the C/C++ programming languages and comprised of over ten million lines of code, and present numerous tasks of the engineering community, including computer-aided design, computational fluid dynamics, and finite element analysis. Static analysis methods are applied to each system to determine the number of jump statements (Goto and Break statements) and functions that are recursively invoked. Functions that contain direct or indirect recursive calls are determined and counted. The results show that number of the used jump statements and functions that have recursive calls are significant and thus pose more of a roadblock to effectively and automatically maintain, comprehend, analyze, and re-engineer systems. Lastly, this leads to inefficiencies in a software engineer's ability to accomplish these common tasks. The study showed that issues in source code stemming from the lack of coding standards have increased over time and are prevalent.

Measuring the internal quality of source code is one of the traditional goals of making software development into an engineering discipline. Cyclomatic complexity (CC) is an often used source code quality metric, next to source lines of code (SLOC). However, the use of the CC metric is challenged by the repeated claim that CC is redundant with respect to SLOC because of strong linear correlation.We conducted an extensive literature study of the CC/SLOC correlation results. Next, we tested correlation on large Java (17.6 M methods) and C (6.3 M functions) corpora. Our results show that linear correlation between SLOC and CC is only moderate as a result of increasingly high variance. We further observe that aggregating CC and SLOC as well as performing a power transform improves the correlation.Our conclusion is that the observed linear correlation between CC and SLOC of Java methods or C functions is not strong enough to conclude that CC is redundant with SLOC. This conclusion contradicts earlier claims from literature but concurs with the widely accepted practice of measuring of CC next to SLOC. Copyright © 2015 John Wiley & Sons, Ltd.

This work presents the results of a study of web sites of 230 OA digital repositories in 16 European countries. The analysis addresses the extent to which these repositories fulfil display characteristics of quality sites, over and above the quality of their content. The objective of this study is to verify whether web sites specifically committed to free access to information satisfy the quality criteria of accessibility, web positioning and quality of the source code. The results obtained find that accessibility must be improved upon, source code quality is merely acceptable, and web positioning is good. In short, bad practices were observed that should not occur in sites whose objective is to facilitate the free access to information.

A significant slowdown in processor performance growth is associated with approaching the physical limits of reducing transistor size. This has led to the situation where traditional ways of increasing performance (increasing the clock frequency or the number of cores) no longer fully deliver performance gains. In modern processors, SIMD (Single Instruction, Multiple Da-ta) instruction-set architectures play an important role in increasing computing performance. They allow a processor to perform one operation on multiple data streams simultaneously on a single core. In such a situation, parallel processing at the data level, implemented using SIMD instructions, becomes key. Directing the compilation process with special directives, options, and proper data organization makes it possible to obtain an optimized, vectorized code without explicitly using SIMD instructions in the program source code. However, the effectiveness of such mechanisms largely depends on a number of factors: the processor architectural features, the compiler version, the source code quality, and the optimizer state. The article analyzes some existing methods and tools for vectorizing code using SIMD instructions and proposes an ap-proach to automating vectorization by inserting labels into source code, detecting section boundaries in compiled code, analyzing instructions within sections, and generating a report with a link to the source code. A comparative analysis of existing vectorization tools and the developed prototype is conducted. The proposed approach allows for automating the verifica-tion of code vectorization with line-level accuracy and works even with aggressive optimiza-tion, including function embedding.

A software system undergoes many code changes, which may affect code quality and maintainability. Refactoring techniques are a common strategy for restructuring source code and improving internal architecture. However, refactoring activities are limited to a catalog of well-known modifications, and we intend to investigate modifications to the source code, looking for patterns that affect its internal quality. In this work, we present a process for identifying code improvements and then learning from the modifications. This process extracts syntactic patterns of code changes and classifies them based on their impact on software maintainability. We executed the classification process on 132,819 code changes from seven GitHub repositories, obtaining 2405 significant code change patterns. Most code change patterns involve simple modifications to structural elements that have only a slight impact on maintainability. These modifications include renaming or moving code elements, simple refactoring, and adding a new implementation. We analyzed both simple modification patterns and many modifications to identify their impact on internal source code quality. The results show how significant a subset of identified patterns is to internal source code quality, as it improves or reduces maintainability variation.

The quality of source code is negatively impacted by code smells. Since the term "code smell" originated, numerous attempts have been made to comprehend it by identifying it using various techniques, such as metric-based, heuristic-based, optimization-based, machine learning (ML)-based, etc. Among these, supervised machine learning (SML) has shown effectiveness in detecting code smells. However, SML techniques have significant limitations, including the dependency on expensive and high-quality labeled data, the need for representative training datasets, and the risk of introducing biases in labeled examples that lead to skewed predictions. To overcome these challenges, this study introduces a method that leverages unsupervised machine learning (UnML) along with feature engineering. Unlike SML, UnML does not require labeled data and minimizes potential biases. The proposed method was evaluated using four datasets containing different types of code smells and was compared with a previous study that used SML techniques. The results indicate that the UnML-based method is effective, achieving outcomes closely aligned with those from the SML approach. This method is especially beneficial in situations where labeled data is scarce or unavailable and can be used to identify new code smells, generate labeled data for SML and detect multiple code smells simultaneously within a codebase.

There exists a large body of work on the specification and detection of anti-patterns in the source code of software systems. However, there are very few studies on the origins of the occurrences of anti-patterns in the source code: do the very design of the systems lead to the occurrences of anti-patterns or are anti-patterns introduced during implementation? Knowing when anti-patterns are introduced could help software designers and developers improve the quality of the source code, for example by eliminating fault-prone anti-patterns early during the design of the systems, even before their implementation. Therefore, we detect occurrences of anti-patterns in design models and in the source code of some systems, trace these occurrences between design and implementation, and study their relation and impact on the source code. First, we analyze both the UML design models and the source code of 10 open-source systems and show that antipatterns exist in design models. We observe that, on average, 37% of the classes in the design models that belong to anti-patterns also exist in the source code and also play roles in the same anti-patterns. Second, we investigate two open-source systems to assess the impact of the anti-patterns in their design models on the source code in terms of changes and faults. We show that classes that have anti-patterns in the design models have more changes and faults in the source code. Our results suggest that the design of the systems lead to anti-patterns and that the antipatterns impact negatively the change-and fault-proneness of the classes in the source code. Thus, designers should be wary of anti-patterns in their design models and could benefit from tools that detect and trace these anti-patterns into the source code.

A key step in Model-Based Design is the deployment of an algorithm as machine code onto a target processor in the production vehicle. Modern software tools automatically generate the algorithmic source code from models. Given the many combinatorial possibilities for realizing a given algorithm within the modeling environment, the generated C source code will be a function of a realization. This dependency is an important consideration because the quality and clarity of the source code impacts the amount of verification and analysis that must be done for production software development. Other factors involved in generating the machine code from the source code, such as compiler optimization and microprocessor architecture, also contribute to this optimization. Organizations that proactively data mine and gather these optimizations into a set of best practices stand to benefit from reduced development times and lower costs. This paper introduces techniques that can be used to generate and measure code constructs used to create a set of best practices for the Simulink modeling environment. The quality of the object code is measured by examining the algorithm compiled within an Integrated Development Environment.

We evaluate the benefits of applying aspect-oriented software development techniques in the context of a large-scale industrial embedded software system implementing a number of crosscutting concerns. Additionally, we assess the feasibility of automatically extracting these crosscutting concerns from the source code. In order to achieve this, we present an approach for reverse engineering aspects from an ordinary application automatically. This approach incorporates both a concern verification and an aspect construction phase. Our results show that such automated support is feasible, and can lead to significant improvements in source code quality.

We were looking for evidence that a connection between source code quality erosion and the developer focus exists. We assumed that more focused developers, i.e. those who are concerned with a well specified part of the source code at a time are likely to commit higher quality code compared to those who are less focused, i.e. committing to various parts of the code. We estimated code quality with the ColumbusQM quality model and developer focus with structural scattering. Despite the assumption sounds quite logical, we could not find any supporting evidence.

There are more and more developers as software is playing increasingly important roles in today’s economic and social development. As a result, evaluating developers’ expertise scientifically has become an urgent need for both Internet companies and developers. However, it seems that there is no satisfactory method to meet this demand currently. In this paper, we propose a solution to profile developers by analyzing their source code. We conduct the analysis of developers in terms of code quantity, code quality, skills, contribution, personalized commit time, and projects they participated in based on the GitLab code repositories. And we comprehensively evaluate developers’ expertise from four perspectives, which are code quantity, code quality, contribution and score of projects they participated in. Compared with existing methods, our evaluation indicators are more comprehensive. We design and implement an online tool that can provide developer searching and profiling. Our tool has been used in Neusoft and Wonders Group to characterize the expertise and performance of their software developers.

Evaluating the quality of software engineering projects in university courses is challenging because it evolves over time and is a time consuming task. Students applying software quality principles need early and constant feedback on their projects to improve their technical competence as software developers. We conducted a case study to explore whether student’ changes have an impact on the project quality by mining a Git repository. We analyzed a total of 2253 changes (commits) from an undergraduate software engineering project to understand the impact on quality of each change measuring metrics (complexity, duplication, maintainability, and security) mined from the repository. This analysis allowed us to identify from students’ contributions challenges and improvement opportunities in engineering practices. As future work, we plan to analyze more projects and extend our analysis with more software metrics.KeywordsSoftware engineering educationMining software repositoriesCommit-impact analysisSoftware qualityProject based learning