Background:Confusing source code requires deliberate comprehension. Recent psychology studies have characterized individual decision-making differences as model-free (fast and automatic) and model-based (slow and deliberative) decision-making. A framework has been proposed to estimate an individual differences in the degree of model-based control.Aims:This study investigates the correlation of the degree of model-based control and the comprehension performance of confusing source code and compares the correlation of comprehension performance between the degree of model-based control and developer skills reported in previous studies.Method:We conducted an observational study using source code with and without confusing code patterns. We measured the degree of model-based control for each participant.Results:Multiple regression analysis on the results of 91 software engineers showed that the degree of model-based control has a positive correlation with the percentage of correct answers for questions about source code with confusing code patterns with statistical significance.Conclusion:In source code reviews, refactoring, and enhancement development, the appropriate developer assignment criteria using developer attributes differ between source code with and without confusing code patterns.

Association rule mining is a highly effective approach to data analysis for datasets of varying sizes, accommodating diverse feature values. Nevertheless, deriving practical rules from datasets with numerical variables presents a challenge, as these variables must be discretized beforehand. Quantitative association rule mining addresses this issue, allowing the extraction of valuable rules. This paper introduces an extension to quantitative association rules, incorporating a two-variable function in their consequent part. The use of correlation functions, statistical test functions, and error functions is also introduced. We illustrate the utility of this extension through three case studies employing software engineering datasets. In case study 1, we successfully pinpointed the conditions that result in either a high or low correlation between effort and software size, offering valuable insights for software project managers. In case study 2, we effectively identified the conditions that lead to a high or low correlation between the number of bugs and source lines of code, aiding in the formulation of software test planning strategies. In case study 3, we applied our approach to the two-step software effort estimation process, uncovering the conditions most likely to yield low effort estimation errors.

In collaborative development of games software, hotspot identification technique significantly supports maintenance and evolutions activities including modding because newly involved developers must identify hotspot. This paper focuses on game loops as hotspots because many action games, including classic action games and the latest action games for console game machines, have an architecture consisting of game loops and update functions. This study assumes that game loops and update functions have the largest number of function calls in the entire source code modules. This paper investigates whether call flow analysis helps developers identify hotspots in four games software publicly accessible in GitHub. The results of the investigation revealed that one game loop and a set of update functions could be identified precisely by call flow analysis and that other three neighborhood functions could be identified. The results showed the possibility of automated identification of game loop and update functions by call flow analysis.

For assuring dependability among systems, it is necessary to describe not only system architecture, but also assurance argument between elements of systems. The composite dependability means for assuring dependability between components of a system. Several approaches have been focused to show the assurance of one single system. Moreover, a unified method to describe both assurance case and system architecture in the same diagram has not been known. This paper proposes a unified method to describe assurance case and system architecture by using an Enterprise Architecture modeling language, Examples of the proposed method are also described. The result shows the method is effectively applicable for assuring dependability of business, application, and technology architecture.

Association rule mining discovers patterns of co-occurrences of attributes as association rules in a data set. The derived association rules are expected to be recurrent, that is, the patterns recur in future in other data sets. This paper defines the recurrence of a rule, and aims to find a criteria to distinguish between high recurrent rules and low recurrent ones using a data set for software defect prediction. An experiment with the Eclipse Mylyn defect data set showed that rules of lower than 30 transactions showed low recurrence. We also found that the lower bound of transactions to select high recurrence rules is dependent on the required precision of defect prediction.

The knowledge which is needed on automotive software development, increases significantly according to large-scale, complexity of automotive software. Therefore, it is very difficult for an engineer to understand the whole software development. This paper introduces a way of constructing a meta-model, which visualizes the knowledge of expert engineers, based on The Seven Samurai framework. It can solve issues of system development by considering the seven types of elements which are defined in this framework. And then, its name was defined based on the famous Japanese cinema. Additionally, this paper shows the evaluation results of applying the meta-model to the evaluation of actual standard software assets in the product line, and then the effectiveness of the proposed approach is confirmed based on the results.

Abstracting and summarizing high-severity defects detected during inspections of previous software versions could lead to effective inspection scenarios in a subsequent version in software maintenance and evolution. We conducted an empirical evaluation of 456 defects detected from the requirement specification inspections conducted during the development of industrial software. The defects were collected from an earlier version, which included 59 high-severity defects, and from a later version, which included 48 high-severity defects. The results of the evaluation showed that nine defect types and their corresponding inspection scenarios were obtained by abstracting and summarizing 45 defects in the earlier version. The results of the evaluation also showed that 46 of the high-severity defects in the later version could be potentially detected using the obtained inspection scenarios. The study also investigated which inspection scenarios can be obtained by the checklist proposed in the value-based review (VBR). It was difficult to obtain five of the inspection scenarios using the VBR checklist. Furthermore, to investigate the effectiveness of cluster analysis for inspection scenario development, the 59 high-severity defects in the earlier version were clustered into similar defect groups by a clustering algorithm. The results indicated that cluster analysis can be a guide for selecting similar defects and help in the tasks of abstracting and summarizing defects.

This paper proposes a fault-prone prediction approach that combines a fault-prone prediction model and manual inspection. Manual inspection is conducted by a predefined checklist that consists of questions and scoring procedures. The questions capture the fault signs or indications that are difficult to be captured by source code metrics used as input by prediction models. Our approach consists of two steps. In the first, the modules are prioritized by a fault-prone prediction model. In the second step, an inspector inspects and scores α percent of the prioritized modules. We conducted a case study of source code modules in commercial software that had been maintained and evolved over ten years and compared AUC (Area Under the Curve) values of Alberg Diagram among three prediction models: (A) support vector machines, (B) lines of code, and (C) random predictor with four prioritization orders. Our results indicated that the maximum AUC values under appropriate α and the coefficient of the inspection score were larger than the AUC values of the prediction models without manual inspection in each of the four combinations and the three models in our context. In two combinations, our approach increased the AUC values to 0.860 from 0.774 and 0.724. Our results also indicated that one of the combinations monotonically increased the AUC values with the numbers of manually inspected modules. This might lead to flexible inspection; the number of manually inspected modules has not been preliminary determined, and the inspectors can inspect as many modules as possible, depending on the available effort.

Background: Association rules are more comprehensive and understandable than fault-prone module predictors (such as logistic regression model, random forest and support vector machine). One of the challenges is that there are usually too many similar rules to be extracted by the rule mining. Aim: This paper proposes a rule reduction technique that can eliminate complex (long) and/or similar rules without sacrificing the prediction performance as much as possible. Method: The notion of the method is to removing long and similar rules unless their confidence level as a heuristic is high enough than shorter rules. For example, it starts with selecting rules with shortest length (length=1), and then it continues through the 2nd shortest rules selection (length=2) based on the current confidence level, this process is repeated on the selection for longer rules until no rules are worth included. Result: An empirical experiment has been conducted with the Mylyn and Eclipse PDE datasets. The result of the Mylyn dataset showed the proposed method was able to reduce the number of rules from 1347 down to 13, while the delta of the prediction performance was only. 015 (from. 757 down to. 742) in terms of the F1 prediction criteria. In the experiment with Eclipsed PDE dataset, the proposed method reduced the number of rules from 398 to 12, while the prediction performance even improved (from. 426 to. 441.) Conclusion: The novel technique introduced resolves the rule explosion problem in association rule mining for software proneness prediction, which is significant and provides better understanding of the causes of faulty modules.

The goal of this research was to assess the consistency of source code comprehension strategies and comprehension effort estimation metrics, such as LOC, across different types of modification tasks in software maintenance and evolution. We conducted an empirical study with software development practitioners using source code from a small paint application written in Java, along with four semantics-preserving modification tasks (refactoring, defect correction) and four semantics-modifying modification tasks (enhancive and modification). Each task has a change specification and corresponding source code patch. The subjects were asked to comprehend the original source code and then judge whether each patch meets the corresponding change specification in the modification task. The subjects recorded the time to comprehend and described the comprehension strategies used and their reason for the patch judgments. The 24 subjects used similar comprehension strategies. The results show that the comprehension strategies and effort estimation metrics are not consistent across different types of modification tasks. The recorded descriptions indicate the subjects scanned through the original source code and the patches when trying to comprehend patches in the semantics-modifying tasks while the subjects only read the source code of the patches in semantics-preserving tasks. An important metric for estimating comprehension efforts of the semantics-modifying tasks is the Code Clone Subtracted from LOC(CCSLOC), while that of semantics-preserving tasks is the number of referred variables.

This paper describes an exploratory study on theuse of screenshots for recording software inspection activities such as defect reproduction and correction. Although detected defects are usually recorded in writing, using screenshots to record detected defects should ecrease the percentage of irreproducible defects and the time needed to reproduce defects during the defect orrection phase. An experiment was conducted to clarify the efficiency of using screenshots to record detected defects. One practitioner group and two student groups participated in the experiment. The recorder in each group used a prototype support tool for capturing screenshots during the experiment. Each group conducted two trials: one with a general spreadsheet application to support recording, the other with the prototype tool that supportsrecording inspection activities. After the inspection meeting, the recorder was asked to reproduce the recorded defects. The percentage of reproduce defects and time to reproduce defects was measured. The results of the experiment show that use of screenshots increases the percentage of reproduced defects and decreases the time needed to reproduce the defects. The results also indicate that use of the recording tool affected the types of defects.

This paper proposes a fault-prone module prediction method that combines association rule mining with logistic regression analysis. In the proposed method, we focus on three key measures of interestingness of an association rule (support, confidence and lift) to select useful rules for the prediction. If a module satisfies the premise (i.e. the condition in the antecedent part) of one of the selected rules, the module is classified by the rule as either fault-prone or not. Otherwise, the module is classified by the logistic model. We experimentally evaluated the prediction performance of the proposed method with different thresholds of each rule interestingness measure (support, confidence and lift) using a module set in the Eclipse project, and compared it with three well-known fault-proneness models (logistic regression model, linear discriminant model and classification tree). The result showed that the improvement of the F1-value of the proposed method was 0.163 at maximum compared to conventional models.

This paper describes an empirical study to reveal factors influencing defect correction effort in software development. In the study we collected various attributes (metrics) of defects found in a typical medium-scale, multi-vendor information system development project in Japan over a six-month period. We then statistically analyzed the relationship between the defects' attributes and the correction effort. The analysis confirmed the well-known principle “defects are the more expensive the later they are detected” by revealing that defects detected in the “system test” were 4.88 times more expensive than those detected in the “coding/unit test”. Another principle “defects are more expensive the longer they survive in software” was also confirmed by revealing that defects, which survived two or more development phases, were 4.44 times more expensive than those detected immediately. We also identified other factors, such as defect reproducibility, severity, and the cause of detection delay, that had a significant influence on the correction effort.

Many of the non conventional software development methodologies (such as object-oriented analysis methodology) and tools (such as visual programming environment) have been applied in real life projects. These projects have been started without sufficient previous training given to the developers. An increment in the productivity has been seen as the projects progress. This paper proposes a simulation model for software development which can deal with variances of developers' productivity during software development. As the proposed model takes into account the developer's learning curve, it can be used to compute a developer's productivity and the quantity of gain to the developer's knowledge in executing an activity. The proposed model has been applied to four typical scenarios in our case study. The results show that it is highly practicable. An outline of a project planning prototype which is based on the proposed model is presented. The prototype can be used to make project plans which take the developer's learning curve into consideration.