Shinsuke Matsumoto

Revisiting common bug prediction findings using effort-aware models

Bug prediction models are often used to help allocate software quality assurance efforts (e.g. testing and code reviews). Mende and Koschke have recently proposed bug prediction models that are effort-aware. These models factor in the effort needed to review or test code when evaluating the effectiveness of prediction models, leading to more realistic performance evaluations. In this paper, we revisit two common findings in the bug prediction literature: 1) Process metrics (e.g., change history) outperform product metrics (e.g., LOC), 2) Package-level predictions outperform file-level predictions. Through a case study on three projects from the Eclipse Foundation, we find that the first finding holds when effort is considered, while the second finding does not hold. These findings validate the practical significance of prior findings in the bug prediction literature and encourage their adoption in practice.

The Effects of Over and Under Sampling on Fault-prone Module Detection

The goal of this paper is to improve the prediction performance of fault-prone module prediction models (fault-proneness models) by employing over/under sampling methods, which are preprocessing procedures for a fit dataset. The sampling methods are expected to improve prediction performance when the fit dataset is unbalanced, i.e. there exists a large difference between the number of fault-prone modules and not-fault-prone modules. So far, there has been no research reporting the effects of applying sampling methods to fault-proneness models. In this paper, we experimentally evaluated the effects of four sampling methods (random over sampling, synthetic minority over sampling, random under sampling and one-sided selection) applied to four fault-proneness models (linear discriminant analysis, logistic regression analysis, neural network and classification tree) by using two module sets of industry legacy software. All four sampling methods improved the prediction performance of the linear and logistic models, while neural network and classification tree models did not benefit from the sampling methods. The improvements of Fl-values in linear and logistic models were 0.078 at minimum, 0.224 at maximum and 0.121 at the mean.

An analysis of developer metrics for fault prediction

Background: Software product metrics have been widely used as independent variables for constructing a fault prediction model. However, fault injection depends not only on characteristics of the products themselves, but also on characteristics of developers involved in the project. Aims: The goal of this paper is to study the effects of developer features on software reliability. Method: This paper proposes developer metrics such as the number of code churns made by each developer, the number of commitments made by each developer and the number of developers for each module. By using the eclipse project dataset, we experimentally analyzed the relationship between the number of faults and developer metrics. Second, the effective of developer metrics for performance improvements of fault prediction models were evaluated. Results: The result revealed that the modules touched by more developer contained more faults. Compared with conventional fault prediction models, developer metrics improved the prediction performance. Conclusions: We conclude that developer metrics are good predictor of faults and we must consider the human factors for improving the software reliability.

Using cloud technologies for large-scale house data in smart city

In the smart city environment, a wide variety of data are collected from sensors and devices to achieve value-added services. In this paper, we especially focus on data taken from smart houses in the smart city, and propose a platform, called Scallop4SC, that stores and processes the large-scale house data. The house data is classified into log data or configuration data. Since the amount of the log is extremely large, we introduce the Hadoop/MapReduce with a multi-node cluster. On top of this, we use HBase key-value store to manage heterogeneous log data in a schemaless manner. On the other hand, to manage the configuration data, we choose MySQL to process various queries to the house data efficiently. We propose practical data models of the log data and the configuration data on HBase and MySQL, respectively. We then show how Scallop4SC works as a efficient data platform for smart city services. We implement a prototype with 12 Linux servers. We conduct an experimental evaluation to calculate device-wise energy consumption, using actual house log recorded for one year in our smart house. Based on the result, we discuss the applicability of Scallop4SC to city-scale data processing.

Application Framework for Efficient Development of Sensor as a Service for Home Network System

The sensor as a service is an emerging application of the services computing. However, how to implement such sensor services efficiently and reliably is an open issue. This paper presents an application framework, called Sensor Service Framework (SSF), that supports developers to build and deploy sensor services in the home network system (HNS). The SSF prescribes device-neutral features and APIs for the sensor devices to be deployed as Web services. Writing a small amount of code with the SSF, the developer can easily deploy any sensor device as a service in the HNS. The sensor service can provide a standardized access to heterogeneous sensor devices, as well as a context management service with user-defined conditions. We then present a {\em sensor mashup platform (SMuP)}, which allows the dynamic composition of the existing sensor services. To support non-expert developers, we also implemented a GUI front-end, called Sensor Service Binder (SSB). The proposed technologies are implemented and evaluated in an actual HNS to demonstlate practical feasibility.

Comparison of Outlier Detection Methods in Fault-proneness Models

In this paper, we experimentally evaluated the effect of outlier detection methods to improve the prediction performance of fault-proneness models. Detected outliers were removed from a fit dataset before building a model. In the experiment, we compared three outlier detection methods (Mahalanobis outlier analysis (MOA), local outlier factor method (LOFM) and rule based modeling (RBM)) each applied to three well-known fault-proneness models (linear discriminant analysis (LDA), logistic regression analysis (LRA) and classification tree (CT)). As a result, MOA and RBM improved Fl-values of all models (0.04 at minimum, 0.17 at maximum and 0.10 at mean) while improvements by LOFM were relatively small (-0.01 at minimum, 0.04 at maximum and 0.01 at mean).

Implementing Virtual Agent as an Interface for Smart Home Voice Control

We have been developing a hands-free voice controller for a home network system (HNS) by using microphone arrays. In our current implementation, however, all human-HNS interactions are performed by voice only. Hence, the interactions tend to be mechanical, dreary and uninformative. To achieve richer interactions, we try to introduce the virtual agent technology as a feedback interface of the HNS. In this paper, we implement the virtual agent as a Web service, by using MMDAgent Toolkit extensively. The agent is then integrated with the HNS and microphone arrays in a service-oriented fashion. Finally, we conduct a user experiment with three versions of virtual agents. In the experiment, we evaluate how the virtual agent can enrich the interactions.

Indoor environment sensing service in smart city using autonomous sensor box

To realize indoor environmental sensing, which is a key technology of providing smart services in smart city, with low cost, our research group has proposed a small IoT device named sensor box. In the previous sensor box, however, it is difficult to deploy for the smart city with some problems. In this paper, we propose an indoor environment sensing service using autonomous sensor box to adapt the previous sensor box for the smart city. To confirm the effectiveness of proposed service, we deploy autonomous sensor boxes on practical indoor environments.

Detecting Service Chains and Feature Interactions in Sensor-Driven Home Network Services

Sensor-driven services often cause chain reactions, since one service may generate an environmental impact that automatically triggers another service. We first propose a framework that can formalize and detect such service chains based on ECA (event, condition, action) rules. Although the service chain can be a major source of feature interactions, not all service chains lead to harmful interactions. Therefore, we then propose a method that identifies feature interactions within the service chains. Specifically, we characterize the degree of deviation of every service chain by evaluating the gap between expected and actual service states. An experimental evaluation demonstrates that the proposed method successfully detects 11 service chains and 6 feature interactions within 7 practical sensor-driven services.

Ubiquitous cloud: Managing service resources for adaptive ubiquitous computing

The adaptive ubiquitous services, which dynamically adapt behaviors to requirements and contexts, are one of the major challenges in the ubiquitous computing. To facilitate the management of ubiquitous service resources, this paper presents a novel platform called ubiquitous cloud, borrowing the concept of the cloud computing. The ubiquitous cloud supports various stakeholders to use appropriate ubiquitous objects in infrastructure, platform and application levels. We present an architecture consisting of four key components: the service resource registry, the adaptive resource finder, the context manager and the service concierge. To demonstrate the effectiveness, we develop a practical adaptive service “room environment relocation service” in an actual home network system, with and without the proposed ubiquitous cloud.