It is challenging to incorporate game elements into software visualization. To achieve this, we propose a new method that generates a shooting game. The difficulty varies based on the number of methods and fields in the modules. Preliminary analysis suggests that the proposed method is expected to help developers grasp the complexity of modules.

Ensemble learning methods have been used to enhance the reliability of defect prediction models. However, there is an inconclusive stability of a single method attaining the highest accuracy among various software projects. This work aims to improve the performance of ensemble-learning defect prediction among such projects by helping select the highest accuracy ensemble methods. We employ bandit algorithms (BA), an online optimization method, to select the highest-accuracy ensemble method. Each software module is tested sequentially, and bandit algorithms utilize the test outcomes of the modules to evaluate the performance of the ensemble learning methods. The test strategy followed might impact the testing effort and prediction accuracy when applying online optimization. Hence, we analyzed the test order's influence on BA's performance. In our experiment, we used six popular defect prediction datasets, four ensemble learning methods such as bagging, and three test strategies such as testing positive-prediction modules first (PF). Our results show that when BA is applied with PF, the prediction accuracy improved on average, and the number of found defects increased by 7% on a minimum of five out of six datasets (although with a slight increase in the testing effort by about 4% from ordinal ensemble learning). Hence, BA with PF strategy is the most effective to attain the highest prediction accuracy using ensemble methods on various projects.

Computer science unplugged (CS unplugged) is a method of teaching computer science and computational thinking. The aim of our study is to illustrate program behavior and to prevent confusion about the program stack through visualization. To facilitate recognition, we used a toy consisting of a ball, pipes, and magnetic panels. The ball represents which line of code is executed, similar to the program counter. To demonstrate the feasibility of the proposed method, we present three examples based on the proposed method. The examples are necessity of loop to wait user input, necessity of loop to keep program running, and software testing. We conducted an experiment with nine participants to evaluate the effectiveness of the proposed method. The result suggested that the proposed method is expected to be effective.

Gamification as a method to enhance the engagement of engineers to software development, has recently received attention. Surveillance is regarded as one of the drawbacks of gamification. We assume that some participants do not like this aspect of gamification, and it can weaken the persuasion and engagement of gamification. To enhance persuasion and engagement, we propose a new approach that utilizes costly apology (i.e., apology which is accompanied with some expenses) and the anchoring effect, and to care emotions of such participants. We assume that apology is needed for participants who are not in much favor of gamification and that a costly apology is more effective than a simple apology. We used a graphical leaderboard as costly apology. The anchoring effect means that the judgment is affected by the information given before the judgment. We used a simple leaderboard as the anchoring information. We preliminarily evaluated the proposed approach through a case study.

To enhance the reliability of software, it is important is to review all software artifacts (e.g., design documents) to remove defects as earlier as possible. There are various review methods available, and project managers face the challenge of choosing a suitable method for their current projects. One of approaches to support the selection of review methods is to evaluate review methods beforehand, to identify the most effective method on average. However, past studies have not evaluated review methods thoroughly as the process can be time-consuming. We propose a bandit-algorithm (BA) based method to evaluate and then dynamically select a suitable review method (from a list of candidates). In our experiments, we assume that the proposed method is applied to design document review on basic design phase. We performed experiments based on a simulation, instead of using an actual dataset. On our simulation, when a review method is selected by our BA method, productivity (i.e., total development time) was improved by about 1.25 times, and it was the second highest among candidates of review methods.

The personality traits of developers can affect software development projects through their performance. The performance of developers can be estimated using these traits. In this study, we focused on grit as it is expected to be effective in estimating productivity. For the estimation, we analyzed the relationship between grit and the time taken to create programs. Unlike previous studies in other fields, grit was not positively related to time (i.e., performance).

Background: Workforce shortage in information technology (IT) has become a pressing issue. To increase the number of female IT professionals, it is important to improve the working environments of female IT professionals. A previous study showed that gender bias is a threat to the outcomes of mathematics tests by females. This influence is called the stereotype threat. Aim: We focused on the stereotype threat to enable female IT developers to deliver their best performance. Method: Using a subjective experiment, we analyzed the relationship between the stereotype threat and the performance of computer programming developers. In addition, we analyzed the effect of eliminating the stereotype threat on programming. Result: Focusing on the time to develop a program, neither the stereotype threat nor the elimination of the threat had any noticeable effect. This result might be affected by the nature of computer programming and a gamification effect.

It is important for software development companies to consider the job satisfaction and turnover intention of employees. To simply explain the factors related to them, this study focused on future perspective index (FPI). The FPI is assumed to relate positively to satisfaction and negatively to turnover. A preliminary analysis improved FPI and allowed for better explained satisfaction and intention than native FPI.

Background: Selecting a suitable feature reduction technique. when building a defect prediction model, can be challenging. Different techniques can result in the selection of different independent variables which have an impact on the overall performance of the prediction model. To help in the selection, previous studies have assessed the impact of each feature reduction technique using different datasets. However, there are many reduction techniques, and therefore some of the well-known techniques have not been assessed by those studies. Aim: The goal of the study is to select a high-accuracy reduction technique from several candidates without preliminary assessments. Method: We utilized bandit algorithm (BA) to help with the selection of best features reduction technique for a list of candidates. To select the best feature reduction technique, BA evaluates the prediction accuracy of the candidates, comparing testing results of different modules with their prediction results. By substituting the reduction technique for the prediction method, BA can then be used to select the best reduction technique. In the experiment, we evaluated the performance of BA to select suitable reduction technique. We performed cross version defect prediction using 14 datasets. As feature reduction techniques, we used two assessed and two non-assessed techniques. Results: Using BA, the prediction accuracy was higher or equivalent than existing approaches on average, compared with techniques selected based on an assessment. Conclusions: BA can have larger impact on improving prediction models by helping not only on selecting suitable models, but also in selecting suitable feature reduction techniques.

Background: defect prediction model is built using historical data from previous versions/releases of the same project. However, such historical data may not exist in case of newly developed projects. Alternatively, one can train a model using data obtained from external projects. This approach is known as cross-project defect prediction (CPDP). In CPDP, it is still difficult to utilize external projects' data or decide which particular project to use to train a model. Aim: to address this issue, we apply bandit algorithm (BA) to CPDP in order to select the most suitable training project from a set of projects. Method: BA-based prediction iteratively reselects the project after each module is tested, considering the accuracy of the predictions. As baselines, we used simple CPDP methods such as training a model with randomly selected project. All models were built using logistic regression. Results: We experimented our approach on two datasets (NASA and DAMB, with a total of 12 projects). The BA-based defect prediction models resulted in, on average, a higher accuracy (AUC and F1 score) than the baselines. Conclusion: in this preliminarily study, we demonstrate the feasibility of using BA in the context of CPDP. Our initial assessment shows that the use BA for predicting defects in CPDP is promising and may outperform existing approaches.

Background: Machine learning models are sometimes embedded in software to implement the required functions. As a result, non-experts in machine learning are becoming familiar with the models. However, the interpretability of the built models is often low in machine learning, such as deep learning, and the recognition process of such models is very different from that of humans. Therefore, it is not easy for novice users, such as end-users and beginners, to anticipate the behavior of models that they will use or build. Aim: We assist novice users to realize an aspect of the behavior of machine learning models relating to robustness intuitively. Method: We formalized and evaluated quiz-based analysis, which is often applied by practitioners to test the robustness of machine learning models arbitrarily. To generate test cases of the models, the analysis converts images towards the boundary of classification for both machine learning and humans. It can be regarded as a type of boundary value analysis of software development. Results: In the experiment, we evaluated whether the analysis quantitatively clarified the aspects of the models. The analysis clarified the robustness of the model for image conversion and misclassification quantitatively. Conclusion: The analysis is expected to enlighten novice users on the behavior of machine learning models. This may promote behavioral changes in the evaluation of models for novice users.

Collecting software-related data is essential to improve software quality and software development processes. In recent years, such data are collected on the users' computer and sent to a server computer. For example, when a software crashes, Android OS displays a form that asks for comments that are manually input by users and sends software-related data on submission. To promote such data collection, we analyzed users' attitude toward data collection. We assumed three types of data collection, i.e., software crash report, user operation of applications, and an activity log of software development. We surveyed 21 students whose major was information science. In the questionnaire, we enquired about their attitudes (e.g., cooperative or not) toward data collection and the reasons for the same. In addition, we asked whether they assumed their trust toward data collecting organizations was high. When risk communication shares exact information of risks to stakeholders, risk recognition is affected by trust. When sending data, users are concerned about the risks of private data leakage. If the users consider that the risk of data collection is low, they will cooperate more with the collection. Our results suggest that explicitly outlining the benefits of cooperation enhances user cooperation. Furthermore, trust toward the data collecting organization is also important for cooperation.

Open source communities have contributed widely to modern software development. The number of open source software (OSS) has increased rapidly in the past two decades. Most open source foundations (such as Eclipse, Mozilla and Apache) operate as non-profit; those foundations usually seek donations from users/developers to financially support their activities. Without such support, some projects might discontinue to develop, or even disappear. However, contributions to those foundations are usually solicited in a very simple and modest way, with no special promotions or attractions for such contributions. The aim of this study is to promote new strategies that can help to increase donations to OSS projects. We analyzed how existing donation pages are structured. We then introduce behavioral economics and psychological theories that have been used in other disciplines to promote donations in OSS. In particular, we used the social proof theory, i.e., where people tend to consider the actions of others in an attempt to reflect correct behavior when they choose their own actions, and legitimization of paltry contributions strategy i.e., using specific phrases such as “even a very small amount will help” to encourage donations. In this study, we conducted an experiment with University students to examine if those theories are effective in encouraging donations to OSS. Our initial results indicate that the two strategies were indeed effective in promoting donations, and showed that users were more open for donation compared to traditional methods. This is only a preliminary analysis - we aim to include more users in the future for a more comprehensive analysis. We anticipate that such techniques might help OSS projects to secure more donations in the future.

Background: The influence of each developer's performance on a project's results (e.g., total software development effort) cannot be ignored. To enhance the performance of each developer, there are various approaches such as improving software engineering education and creating development support tools. In this study, we selected gamification and posing (power posing) and evaluated the effects of these approaches on coding. They are expected to improve the mental state and the motivation of developers. Aim: Select which method (gamification or posing) should be used to enhance developers' work efficiency. Method: Subjects created programs based on given specifications. Group A (Gamification was applied to a task) and group B (Posing was applied to a task) were made. We evaluated the coding time of each group. Results: Gamification was more effective than posing for reducing coding time.

[Context]: Software productivity analysis is an essential activity for software process improvement. It specifies critical factors to be resolved or accepted from project data. As the nature of project data is observational, not experimental, the project data involves bias that can cause spurious relationships among analyzed factors. Analysis methods based on linear regression suffer from the spurious relationships and sometimes lead an inappropriate causal relation. The propensity score is a solution for this problem but has rarely been used. [Objective]: To investigate what differences the use of propensity score brings to software productivity analysis in comparison to a conventional method. [Method]: We revisited classical software productivity analyses on ISBSG and Finnish datasets. The differences of critical factors between the propensity score and the linear regression were investigated. [Results]: Both analysis methods specified different critical factors on the two datasets. The specified factors were both reasonable to some extent, and further considerations are needed for the propensity score results. [Conclusions]: The use of propensity score can lead new possible factors to be tackled. Although the contradiction does not necessarily indicate a flaw of the linear regression, the results by the propensity score should also be noticed for better actions.

We focus on developer code review performance, and analyze whether the age of a subject affects the efficiency and preciseness of their code. Generally, older coders have more experience. Therefore, the age is considered to positively affect code review. However, in our past study, code understanding speed was relatively slow for older subjects, and memory is needed to understand programs. Similarly, during code review, a subject's age may affect efficiency (e.g., the number of indications per unit time). In the experiment, subjects reviewed source code, referring to mini specification documents. When the code did not follow the document, the subjects indicated the error. We classified subjects into senior and junior groups. In the analysis, we stratified the results based on age, and used correlation coefficients and multiple linear regression to clarify the relationship between age and review performance. We found that age does not affect the efficiency and correctness of code review. Also, the software development experience of subjects is not significantly correlated to performance.

In a software development project, project management is indispensable, and effort estimation is one of the important factors on the management. To improve estimation accuracy, outliers are often removed from dataset used for estimation. However, the influence of the outliers to the estimation accuracy is not clear. In this study, we added outliers to dataset experimentally, to analyze the influence. In the analysis, we changed the percentage of outliers, the extent of outliers, variable including outliers, and location of outliers on the dataset. After that, effort was estimated using the dataset. In the experiment, the influence of outliers was not very large, when they were included in the software size metric, the percentage of outliers was 10%, and the extent of outliers was 100%.

Recently, information system operation becomes more important because of increasing size of information system and outsourcing the system operation. However, it is not easy for customers to judge the validity of the system operation cost. To provide information which helps the judgment, we analyzed factors which affect system operation cost. Working time of system operation service provider has the strong relationship to the cost. So, if customers know the working time, they estimate the cost properly. However, it is difficult for customers to know the working time generally. So, we assumed that customers estimate unit cost and working time, to speculate total operation cost roughly. To help the estimation, we analyzed factors affected working time and unit cost. The analysis results show that working time is settled based on the software size and the number of users, and the unit cost of the engineers increases when network range of the system is wide.

To enhance the quality of software, many software development support tools and software development methodologies have been proposed. However, not all proposed tools and methodologies are widely used in software development. We assume that the evaluation of tools and methodologies by developers is different from the evaluation by researchers, and that this is one of the reasons why the tools and methodologies are not widely used. We analyzed the decision criteria of software developers as applied to the tools and methodologies, to clarify whether the difference exists or not. In behavioral economics, there are theories which assume people have biases, and they do not always act reasonably. In the experiment, we made a questionnaire based on behavioral economics, and collected answers from open source software developers. The results suggest that developers do not always act to maximize expected profit because of the certainty effect and ambiguity aversion. Therefore, we should reconsider the evaluation criteria of tools such as the f-measure or AUC, which mainly focus on the expected profit.

It is important to establish a benchmark of work efficiency for software maintenance and support. For maintenance and support service providers, the benchmarking is the basis for improvement of their work. For the service purchasers, it is useful to check work efficiency of contracted service provider. To establish a benchmark of work efficiency for software development activities, a cross-company dataset is often used. Data points included in it are collected from various organizations. ISBSG (International Software Benchmarking Standards Group) builds the cross-company dataset of software maintenance and support. In the analysis, we found some pitfalls when one analyzes ISBSG software maintenance and support dataset. If the pitfalls are ignored, spurious relationships would be found. In this paper, we showed some pitfalls, and how to avoid it. It would be very useful for researchers, because ISBSG software maintenance and support dataset may be widely used in the near future.

Software development effort estimation is an essential aspect of software project management. An effort estimation model expresses relationships between effort and factors such as organizational and project features (e.g. software functional size, and the programming language used in a project). However, software development practices and tools change over time, to environmental changes. This can affect some relationships assumed in an effort estimation model. A moving windows method (a method for treating the timing information of projects), has thus been proposed for estimation models. The moving windows method uses data from a fixed number of the most recent projects data for model construction. However, it is not clear that moving windows is the best way to handle the timing information in an estimation model. The goal of our research is to determine how best to treat timing information in constructing effort estimation models. To achieve the goal, we compared six different methods (moving windows, dummy variable of moving windows, dummy variables of equal bins, dummy variables of year, year predictor, and serial number) for treating timing data, in terms of estimation accuracy. In the experiment, we use three software development project datasets. We found that moving windows is best when the number of projects included in the dataset is not small, and dummy variable of moving windows is the best when the number is small.

Many research projects on software estimation use software size as a major explanatory variable. However, practitioners sometimes use the ratio of effort for early phase activities such as planning and requirement analysis, to the effort for the whole development phase of the software in order to estimate effort. In this paper, we focus on effort estimation based on the effort for early phase activities. The goal of the research is to examine the relationship of early phase effort and software size with software development effort. To achieve the goal, we built effort estimation models using early phase effort as an explanatory variable, and compared the estimation accuracies of these models to the effort estimation models based on software size. In addition, we built estimation models using both early phase effort and software size. In our experiment, we used ISBSG dataset, which was collected from software development companies, and regarded planning phase effort and requirement analysis effort as early phase effort. The result of the experiment showed that when both software size and sum of planning and requirement analysis phase effort were used as explanatory variables, the estimation accuracy was most improved (Average Balanced Relative Error was improved to 75.4% from 148.4%). Based on the result, we recommend that both early phase effort and software size be used as explanatory variables, because that combination showed the high accuracy, and did not have multicollinearity issues.

In past research, we proposed an authentication method that combines actions with spatiotemporal information such as location, time, and distance. With the method, a user succeeds in authentication when he/she performs preset actions such as pushing button n times on preset intervals defined by spatiotemporal information. In this paper, we improve the authentication method using a partial matching method. We propose two kinds of partial matching methods for pushing button and interval. A type I method assumes the number of pushing button is sometimes less than preset count, but the number never exceeds it, and a user never pushes the button out of preset areas. A type II method assumes the number of pushing button is less or more than preset count occasionally, and a user pushes the button out of preset areas. We showed how to calculate FAR when the type I or II is applied. In the experiment, we compared the type I and II methods with a conventional method to evaluate their security. As a result, the type I method improved false acceptance rate (FAR) from 0.097% to 0.053%. The type II method improved FAR from 0.097% to 0.035%.

One of the common problems in building an effort estimation model is that not all the effort factors are suitable as predictor variables. As a supplement of missing information in estimation models, this paper explores the project manager's knowledge about the target project. We assume that the experts can judge the target project's productivity level based on his/her own expert knowledge about the project. We also assume that this judgment can be further improved, because using the expert's judgment solely could incur subjective perception. This paper proposes a regression model building/selection method to address this challenge. In the proposed method, a fit dataset for model building is divided into two or three subsets by project productivity, and an estimation model is built on each data subset. The expert judges the productivity level of the target project and selects one of the models to be used. In the experiment, we used three datasets to evaluate the produced effort estimation models. In the experiment, we adjusted the error rate of the judgment and analyzed the relationship between the error rate and the estimation accuracy. As a result, the judgment-incorporating models produced significantly higher estimation accuracy than the conventional linear regression model, where the expert's error rate is less than 37%.

Background: Accurate effort estimation is the basis of the software development project management. The linear regression model is one of the widely-used methods for the purpose. A dataset used to build a model often includes categorical variables denoting such as programming languages. Categorical variables are usually handled with two methods: the stratification and dummy variables. Those methods have a positive effect on accuracy but have shortcomings. The other handing method, the interaction and the hierarchical linear model (HLM), might be able to compensate for them. However, the two methods have not been examined in the research area. Aim: giving useful suggestions for handling categorical variables with the stratification, transforming dummy variables, the interaction, or HLM, when building an estimation model. Method: We built estimation models with the four handling methods on ISBSG, NASA, and Desharnais datasets, and compared accuracy of the methods with each other. Results: The most effective method was different for datasets, and the difference was statistically significant on both mean balanced relative error (MBRE) and mean magnitude of relative error (MMRE). The interaction and HLM were effective in a certain case. Conclusions: The stratification and transforming dummy variables should be tried at least, for obtaining an accurate model. In addition, we suggest that the application of the interaction and HLM should be considered when building the estimation model.

Recently, software functional size becomes larger, and consequently, not only a software developer but also a software purchaser suffers considerable losses by software project failure. So avoiding project failure is also important for purchasers. Project supervision (monitoring and control) is expected for the purchaser to suppress risk of project failure. It is performed by sharing software metrics during the project for the purchaser to grasp the status of the project, and corrective actions are done based on analysis results of the metrics. Although there are some software measurement models, the models are not enough to describe how to confirm effects of project supervision. To acquire the effects certainly, the purchaser and the developer should quantitatively confirm whether the effects are acquired or not by project supervision. In addition, the models cannot represent corrective actions when symptoms of project failure are found. We propose the model for project supervision. The model explains planning, collecting data, transforming data, analyzing data, reaction toward found issues, and confirming effect of project supervision. With our model, project supervision can be described more rigorously.

Analogy-based cost estimation provides a useful and intuitive means to support decision making in software project management. It derives a cost estimate required for completing a project from information about similar past projects, namely the analogues. While on average this method provides a relatively accurate cost estimate there remains a possibility of large estimation errors. In this paper, we empirically tested the hypothesis that "using more homogeneous analogues produces a more reliable cost estimate" using a software engineering data repository established by the software engineering center (SEC), Information-technology Promotion Agency, Japan. This testing showed that low and high homogeneity projects had a large variation in estimation reliability. For instance, the difference was 22.9% (p = 0.021) in terms of percentage to get accurate estimates (better than Median of Magnitude of Relative Error).

Software engineers have to select some appropriate development technologies to use in the work; however, engineers sometimes cannot find the appropriate technologies because there are vast amount of options today. To solve this problem, we propose a software technology recommendation method based on collaborative filtering (CF). In the proposed method, at first, questionnaires are collected from concerned engineers about their technical interest. Next, similarities between an active engineer who gets recommendation and the other engineers are calculated according to the technical interests. Then, some similar engineers are selected for the active engineer. At last, some technologies are recommended which attract the similar engineers. An experimental evaluation showed that the proposed method can make accurate recommendations than that of a naive (non-CF) method.