Investigating the Role of Software Quality Managers and Software Developers in Creating Code Smells

Software code smells are regarded as signs of potential problems in code design or implementation, they might not affect functionality but impact future maintenance and readability. However, refactoring is a process of code transformation that improves code structure without changing code behavior. This process occurs in the stage of software maintenance where software developers and software quality managers/engineers must work closely in order to identify code smells and plan for refactoring. This research aims to investigate the role of quality managers and software developers in creating code smells.

Introduction

Software code smells are the red flags in the code. They might not affect the current functionality of the software system [1], [2]. Throughout the software development processes, quality assurance is a crucial activity [3]–[5]. One of the activities in quality assurance is checking or detecting code smells during proactive maintenance [6].

This research focuses on the investigation of the impact made by both software quality managers and software developers towards the existence of code smells. To effectively conduct the data collection, two classes of participants are targeted for this research purpose. The participants will be provided with a set of questions in the form of a questionnaire.

This paper is structured as follows. First, general background and discussion of related work are provided and explained. Secondly, the research questions, along with the research methodology, are explained and elaborated. Thirdly, the main findings of this research are illustrated and discussed. Finally, the conclusions on the findings and the limitations of this research are drawn and explained.

Related Work and Background

Software development is not a straightforward task [7]. Different methodologies are introduced and used for software development. These methodologies can be categorized as traditional, dynamic, and adaptive [8], [9]. The most common methodology nowadays is Agile, which is an adaptive methodology [8], [10], [11].

Software quality can be defined as the extent to which the software meets the needs and expectations specified in the requirements of the software [12]–[15]. When considering software quality, many quality attributes are shaping the software quality. One of these quality attributes is Maintainability, which can be regarded as the extent to which the software can be altered for corrections, improvements, and/or changes of requirements [16], [17].

Maintenance is regarded as the process which takes place after the delivery of software in order to fix or change the software for improvement or requirement change [11], [18], [19]. In addition, the most famous maintenance activities are proactive and reactive maintenance. Proactive maintenance is the type of maintenance to perfect the code, whereas reactive maintenance is the type to fix the code [6].

Software code smells are regarded as signs of future issues in code design or implementation; however, software functionalities might not be affected at the time of detection, but code smells might affect the future maintainability and readability of the software code [20]–[24]. Therefore, the process of renovating these code smells might be crucial and is termed as software refactoring, which is one of many activities in software development in specific maintenance activities and it is a code transformation process that improves code structure without changing code behavior [1], [2], [24]–[26].

Many have reviewed the topic of code smells [27]–[32]. The reviews uncover the main topics related to code smells. These topics can be summarized in the following: 1) code smells understanding, 2) code smells impact, 3) code smells catalogs, 4) code smells detection, 5) code smells refactoring. In addition, he explained some of the challenges and related aspects of code smells such as fixing, prediction, and rating of code smells.

Many have introduced their lists or catalogs of code smells [22], [33]–[35] in different types of software projects. In addition, new code smells have been introduced and validated. This shows that code smells are not fixed; however, new types emerge as technology improves and software becomes more complex.

Many have introduced their approaches to detect or predict code smells in the source code [20], [36]–[42]. Some of these approaches are automated with tool support, and others are not. In addition, it is worth noting that machine learning algorithms are common to be used an automated code smell detection. However, a lack of maturity might exist in the approaches that are offered.

Pecorelli et al. [43] have offered a new approach for prioritizing code smells according to their criticality. The approach relies on machine learning and developers understanding of the code smells. The authors preferred to name this approach developer-driven. The approach has been compared to two other similar approaches [44], [45], and the authors have reported an outperformance of their approach.

Alfadel et al. [46] have studied the relationship between the existence of design patterns and the existence of code smells. The authors considered 20 software design patterns and 13 common code smells in their investigation. The investigation was carried out on 10 open-source codes of Java. The outcomes of this investigation showed a strong relation between some of the design patterns and certain code smells. In addition, the author reported that entities of code that form a design pattern probably do not have code smells.

Muse et al. [47] have investigated the Impact of SQL code smells in Data-Intensive Systems. The authors have conducted an empirical investigation on 150 software projects to study the frequency and impact of SQL code smells and compare them with the common code smells in code. The findings of their work were that they noticed a widespread of SQL code smells and noticed that they often occur earlier in the project development phases and remained not fixed.

Han et al. [48] have studied the relationship between the identification of code smells and the actions taken by software developers. The authors have conducted an experiment on 2 OpenStack projects and collected over 1000 reviews of code smells out of over 19000 reviews, which have been done by, perhaps, software quality engineers or software professionals who are interested in software quality. The authors concluded that code smells are not often identified when code is checked or reviewed.

Yamashita et al. [49] have investigated the factors which might affect the maintenance of software code. The authors consider the work in [50], [51] which offer a set of factors that might affect maintainability of software code. In addition, the authors offer new factors after conducting an empirical study on 6 developers with 4 software projects and discovered a total of 13 factors.

Furthermore, Yamashita et al. [52] conducted a survey of 85 software professionals to investigate the understanding of code smells and concluded that a considerable number of professionals showed ignorance of code smells. In addition, the authors reported that professionals showed a lack of interest in building the code with consideration of avoiding the code smells.

Research Questions

This research focuses on investigating the role of software quality managers in software developers’ creation of code smells. Therefore, two main research questions have been formulated:

1) Are the code smells checks a regular action in the software development processes?

2) What are the reasons behind creating code smells in source code by software developers?

Answering these questions requires conducting surveys to collect data and analyze it to draw conclusions. Therefore, two types of participants are needed to participate in this research, specifically software quality managers and software developers.

Methodology

In this research a questionnaire was designed in order to collect the required data to answer the research questions. The questionnaire consists of two parts. The first part collects the consent of participation and some personal information such as gender, experience, and job titles. Based on the participants’ responses to the job title question in the first part, the second part displays the appropriate questions in order to collect either the software developers’ opinions or the software quality managers’ opinions. Google Forms was used to create the questionnaire, which was later sent to the intended participants via emails and direct text messaging.

The questionnaire was sent to 150 participants, and the collected responses were 52. Fig. 1 illustrates the distribution of the responses based on the job titles and the gender of participants. It can be seen from Fig. 1 that around 85% of respondents are males. On the other hand, 73% of the respondents are developers.

Fig. 1. Division of participants based on gender and job title.

The questionnaire is built with a Likert scale question, which allows the participants to specify their answers on a scale from 0 to 5, where 0 is never and 4 is always. The respondents are allowed to opt for the not applicable as 5. This scale is for the questions that are related to software quality managers and software developers regarding the Code Smells Checks frequency. However, other questions were asked using a scale from 0 to 4. Finally, the question for the software developers to rate their knowledge on the code smells is in addition using the scale from 0 to 4 where 0 refers to none and 4 refers to excellent.

Results and Discussion

In this section, the main findings of our questionnaire will be presented and discussed. The first subsection will show the results of the questions which were answered by the Software quality managers and software developers regarding the frequency of checks for code smells in different programming languages. The second subsection will illustrate the results of the questions that have been answered by Software quality managers regarding their perspectives. The third subsection will show and discuss the results of questions which have been answered by the software developers.

Frequency of Checks for Code Smells in Different Programming Languages

Participants have been asked to specify the scale of frequency of checks for code smells in several programming languages, which are Java, JavaScript, C, C++, C#, Visual Basic, and Python. The following are the presentations and discussions of these findings.

It can be noticed in Fig. 2 that around 37% of software developers participants specified that it is always or often that they conduct a code smell checks in their Java source code. However, the same portion of the software developers are stating that they have not conducted any code smells checks. This might lead to a reduction in the number of Java programmers. On the other hand, 50% of software quality managers specified rare or never as the frequency of code smells checks in source code made using Java programming language.

Fig. 2. Frequency of checks for code smells in Java.

With regards to checks for code smells in source code made in JavaScript, it is obvious from Fig. 3 that 56% of software developers expressed that they often or always conducted checks. However, software quality managers stated the opposite opinion, as 57% of them stated that they rarely or never carried out code smells checks in source code made using Java programming language.

Fig. 3. Frequency of checks for code smells in JavaScript.

In Fig. 4, some agreement appears between software developers and software quality managers, as they tend to rarely or never conduct code smell checks in source code made in C programming language, with 44% and 72%, respectively. Moreover, It is important to note that 32% of software developers stated “not applicable” for this matter.

Fig. 4. Frequency of checks for code smells in C.

Considering source codes made in C#, as seen in Fig. 5 66% of software developers and 64% of software quality managers have answered with “rarely” or “not applicable.” However, 19% of software developers stated that they often or always conducted code smells checks on source code made in C#. On the other hand, 21% of software quality managers stated that they often conduct code smells checks on source code made in C#.

Fig. 5. Frequency of checks for code smells in C#.

Fig. 6 shows that 71% of software quality managers specified the answer of the frequency they conduct code smells checks on source code made in C++ programming language as “rarely,” “never,” or “not applicable.” On the other hand, 52% of software developers tend to have the same answer. It is worth noting that 29% of software developers stated that they always or often conduct code smells checks for C++ projects.

Fig. 6. Frequency of checks for code smells in C++.

With regards to checks for code smells in source code made in Visual Basic programming language, Fig. 7 illustrates that software quality managers and software developers have specified the answers for frequency as “never” or “not applicable,” with percentages of 64% and 55%, respectively. However, software quality managers and software developers have specified the answers for frequency as “often,” with percentages of 21% and 11%, respectively.

Fig. 7. Frequency of checks for code smells in Visual Basic.

As can be seen in Fig. 8, software quality managers and software developers have specified the answers for frequency for checking code smells in projects in Python source codes as “often” or “always,” with percentages of 43% and 37%, respectively. Interestingly, the other portion of the software quality managers participants chose “rarely” or “never.” However, 42% of software developers specified “never” or “not applicable” as their answers.

Fig. 8. Frequency of checks for code smells in Python.

Software Quality Managers’ Perspectives

In this subsection, the results of the questions which have been provided to the software quality managers are illustrated and discussed. These questions are to measure the impact of software developers in imposing code smells and to measure the impact of software code smells awareness encouraged by software quality managers.

Fig. 9 demonstrates the opinion of the software quality managers on the frequency that software developers contribute to the production of code smells. It is obvious from Fig. 9 that 42% of software quality managers believe that code smells are always or often caused by software developers.

Fig. 9. Software quality managers’ opinions on developers creating code smells.

On the other hand, 50% of software quality managers, as can be seen in Fig. 10, admitted that they were rarely or never required to explain or raise awareness of code smells for software developers. The results shown in Figs. 9 and 10 can be linked in order to find correlation between lack of awareness raise and developers making code smells.

Fig. 10. Frequency of need for Code Smell explanations to developers.

Software Developers’ Perspectives

In this subsection, the results of the questions which were given to software developers are demonstrated and discussed. The questions are to investigate the software developers’ knowledge of code smells and the frequency of proactive and reactive code maintenance that the developers conduct.

Fig. 11 shows that 43% of software developers rated their knowledge of code smells as “high” or “excellent.” However, 59% of developers articulated that their knowledge of code smells is “medium” or less. This shows that knowledge of code smells is not high around software developers.

Fig. 11. Software developers rate of knowledge in code smells.

With the difference discussed earlier in this paper between proactive and reactive maintenance, software developers were asked to specify the frequency of conducting each of them. Figs. 12 and 13 illustrate that more than 60% of software developers either always or often conduct software maintenance proactively or reactively. This might link to the results shown in Fig. 11, as 59% of developers articulated that their knowledge of code smells is “medium” or less. It seems that developers cannot distinguish proactive and reactive maintenance.

Fig. 12. Frequency of proactive maintenance.

Fig. 13. Frequency of reactive maintenance.

Conclusion

This study shows the results of the investigation of the impact made by both software quality managers and software developers towards the existence of code smells. The results of the investigation can be summarized as follows.

The participants’ answers for the frequency of code smells checks for several well-known programming languages were illustrated and discussed. Interesting results have been discovered. In general, code smells checks are not regular action in software development processes. In addition, an interest in code smells check might be noticed in source code made in Java, JavaScript, C++, and Python.

In addition, it can be claimed that there is a relationship between software developers’ awareness of code smells, and the judgment of the software quality managers of developers being the reason behind more code smells in source codes.

Furthermore, the software developers’ knowledge on code smells and types of maintenance seems not satisfactory and might be a reason behind producing code smells in software source codes. From the discussed results in the previous sections, it can be seen clearly that there is a gap between software development and software quality assurance.

The limitations of this study can be seen in the number of participants. In order to generalize the results and conclusions, more participants are required. However, the current number allows us to hold the lead for the case, and the current conclusions are valid as initial conclusions. In addition, it might be better to have an equal number of software quality managers to the number of software developers.