Since programming languages offer a wide variety of grammers, desired functions can be implemented in a variety of ways. We consider that there is a large amount of source code that has different implementations of the same functions, and that those can be compiled into a dataset useful for various research in software engineering. In this study, we construct a dataset of functionally equivalent Java methods from about 36 million lines of source code. The constructed dataset is available at https://zenodo.org/record/5912689.

End-to-end test automation is critical in modern web application development. However, test automation techniques used in industry face challenges in implementing and maintaining test scripts. It is difficult to determine and maintain the locators needed by test scripts to identify web elements on web pages. The reason is that locators depend on the metadata of web elements and the structure of each web page. One effective way to solve such a problem of locators is to allow test cases written in natural language to be executed without test scripts. In this study, we propose a technique to identify web elements that should be operated on a web page by interpreting natural-language-like test cases. The test cases are written in a domain-specific language that independents on the metadata of web elements and the structural information of web pages. We leverage natural language processing techniques to understand the semantics of web elements. We also create heuristic search algorithms to explore web pages and find promising test procedures. To evaluate the proposed technique, we applied it to test cases for two open-source web applications. The experimental results show that our technique was able to successfully identify about 94% of web elements to be operated in the test cases. Our approach also succeeded in identifying all the web elements that were operated in 68% of the test cases.

Abstract In software development, ad hoc solutions that are intentionally implemented by developers are called self-admitted technical debt (SATD). Because the existence of SATD spreads poor implementations, it is necessary to remove it as soon as possible. Meanwhile, container virtualization has been attracting attention in recent years as a technology to support infrastructure such as servers. Currently, Docker is the de facto standard for container virtualization. In Docker, a file describing how to build a container (Dockerfile) is a set of procedural instructions; thus, it can be considered as a kind of source code. Moreover, because Docker is a relatively new technology, there are few developers who have accumulated good or bad practices for building Docker container. Hence, it is likely that Dockerfiles contain many SATDs, as is the case with general programming language source code analyzed in previous SATD studies. The goal of this paper is to categorize SATDs in Dockerfiles and to share knowledge with developers and researchers. To achieve this goal, we conducted a manual classification for SATDs in Dockerfile. We found that about 3.0% of the comments in Dockerfile are SATD. In addition, we have classified SATDs into five classes and eleven subclasses. Among them, there are some SATDs specific to Docker, such as SATDs for version fixing and for integrity check. The three most common classes of SATD were related to lowering maintainability, testing, and defects.

Software testing is being leveraged in programming education for automated assessment of programming assignments. When using software testing in programming education, program specifications are provided as unit or integration tests, and students create programs that pass these tests. Although this method has various advantages, such as ensuring objective program specifications and automating the operation check, it also has many disadvantages. For example, detecting innovations, such as original specifications and functional extensions by an individual student, is difficult. The purpose of this research is to automatically detect functional differences among student programs in programming education using tests. In our proposed method, automatic test generation is applied to student programs, and the generated tests are mutually executed for other student programs. Furthermore, we classify the tests based on the execution path to obtain sets of tests that are capable of detecting functional differences.

Automated program generation (APG) is a concept of automatically making a computer program. Toward this goal, transferring automated program repair (APR) to APG can be considered. APR modifies the buggy input source code to pass all test cases. APG regards empty source code as initially failing all test cases, i.e., containing multiple bugs. Search-based APR repeatedly generates program variants and evaluates them. Many traditional APR systems evaluate the fitness of variants based on the number of passing test cases. However, when source code contains multiple bugs, this fitness function lacks the expressive power of variants. In this paper, we propose the application of a multi-objective genetic algorithm to APR in order to improve efficiency. We also propose a new crossover method that combines two variants with complementary test results, taking advantage of the high expressive power of multi-objective genetic algorithms for evaluation. We tested the effectiveness of the proposed method on competitive programming tasks. The obtained results showed significant differences in the number of successful trials and the required generation time.

End-to-end test automation is important in modern web application development. However, existing test automation techniques have challenges in implementing and maintaining test scripts. It is difficult to keep correct locators, which test scripts require to identify web elements on web pages. The reason is that locators depend on the metadata in web elements or the structure of each web page. One efficient way to solve the problem of locators is to make test cases written in natural language executable without test scripts. As the first step of script-free testing, we propose a technique to identify web elements to be operated and to determine test procedures by interpreting test cases. The test cases are written in a domain-specific language without relying on the metadata of web elements or the structural information of web pages. We leverage natural language processing techniques to understand the semantics of web elements. We also create heuristic search algorithms to find promising test procedures. To evaluate our proposed technique, we applied it to two open-source web applications. The experimental results show that our technique successfully identified 94% of web elements to be operated in the test cases.

The concept of the test smell represents potential problems with the readability and maintainability of the test code. Common test smells focus on static aspects of the source code, such as code length and complexity. These are easy to detect and do not cause problems in terms of test execution. On the other hand, dynamic smells, which are based on test runtime behavior, lead to misunderstanding of the test results. For example, rotten green tests give developers the false impression that the test was passed without any problems, even though the test was poorly executed. Therefore, we should detect dynamic smells and take countermeasures as early as possible through the development. In this paper, we introduce JTDog, a Gradle plugin for dynamic smell detection. JTDog has high portability due to its integration into the build tool. We applied JTDog to 150 projects on GitHub and confirmed that the JTDog plugin has high portability. In addition, JTDog detected 958 dynamic smells in 55 projects. JT-Dog is available at https://github.com/kusumotolab/JTDog, and the demo video is available at https://youtu.be/t374HYMCavI.

Many programming languages have a system of garbage collection to automate memory management. Problems such as unexpected memory leak still may occur due to the automation of memory management. Weak reference has been proposed as a solution to such problems. However, the use of weak reference often requires consideration of memory release timing, which is difficult for developers. In this study, we investigate the use of weak reference on open source projects. More concretely, we investigated the domain of software projects where the weak reference was used, the timing of the introduction of the weak reference, the usage method, the presence or absence of the test code for weak reference, and the case of failure to introduce weak reference in the Java language. The survey showed that weak references were used in 73 repositories, about one-third of the total 202 repositories, and that weak references were most common in test code.

Understanding program comprehension is one of the fundamental challenges of supporting software development. Although code writing is usually performed on programming specific environment, code reading is forced to be conducted in general environments such as physical paper. Our main hypothesis is that such a non-programming specific environment has some obstacles for program comprehension in terms of code presentation. The goal of this paper is to understand the effects on cognitive load caused by the obstacles. If our hypothesis will be proved and the goal will be achieved, we can provide the best practice of code presentation in non-programming specific environment.

Spectrum-Based Fault Localization (in short, SBFL) is one of the popular techniques to localize faulty code fragments of a given program. SBFL utilizes the information about which statements are executed by each of the success or failure test cases. There are various implementation ways for the same functionality if we use high-level programming languages. The authors consider that differences in these implementation ways may affect the efficiency of localizing faults using SBFL. In this paper, we define a characteristic to what extent a program is suitable for SBFL as SBFL-Suitability, and we propose a technique for measuring SBFL-Suitability. The proposed technique generates many slightly-variant programs from a given program with Mutation Testing, and then it measures how accurately SBFL detects the changed program statements in the variant programs. We conducted an experiment to investigate how SBFL-Suitability differs depending on the differences in source code structures. As a result, we found that (1) the fewer statements in the same nesting level, the higher SBFL-Suitability tends to be, and (2) the presence of Early Return improves SBFL-Suitability.

The sufficiency of test cases is essential for spectrum-based fault localization (in short, SBFL). If a given set of test cases is not sufficient, SBFL does not work. In such a case, we can improve the reliability of SBFL by adding new test cases. However, adding many test cases without considering their properties is not appropriate in the context of automated program repair (in short, APR). For example, in the case of GenProg, which is the most famous APR tool, all the test cases related to the bug module are executed for each of the mutated programs. Execution results of test cases are used for checking whether they pass all the test cases and inferring faulty statements for a given bug. Thus, in the context of APR, it is important to add necessary minimum test cases to improve the accuracy of SBFL. In this paper, we propose three strategies for selecting some test cases from a large number of automatically-generated test cases. We conducted a small experiment on bug dataset Defect4J and confirmed that the accuracy of SBFL was improved for 56.3% of target bugs while the accuracy was decreased for 17.3% in the case of the best strategy. We also confirmed that the increase of the execution time was suppressed to 1.5 seconds at the median.

Comparing and selecting the most appropriate JavaScript Framework (JSF) is an important activity for web application development. However, it is difficult to collect much information for comparison of JSFs. In this paper, we present a playground tool named Jact to support comprehension of individual JSF characteristics. By the concept of playground, users can freely run, edit, and share source code in their web browsers. Based on the concept, Jact enables developers to compare source codes and runtime performances of each JSF based on typical tasks in web development. Task-based comparison is useful for understanding the feature of each JSF. Furthermore, developers can submit tasks and source code which uses a specific JSF. By sharing tasks and source code written by not only administrators but also developers, Jact can continuously provide information relating to JSF, which includes benchmark and API usage. In order to evaluate the effectiveness of Jact, we conducted a subject experiment with 13 participants. Jact is currently available at http://13.231.18.92.

Programming education focusing on the correctness of program behavior is often conducted with automated testing. However, it is difficult to instruct students about internal program quality since automated testing confirms only the external behavior of the program. Although there are a lot of quality measuring tools, results in these tools are so detailed or complicated that students cannot handle them. Besides, these tools do not give explicit criteria to judge the quality of the given program, thus students cannot figure out how high their program quality is. As a result, using these tools does not lead to improving the program quality. In this paper, we propose an educational method in which visualize the program quality by introducing a concept called achievement. We also introduce an implemented prototype system, Ave, to realize the proposed method.

Daylight saving time (DST) is observed in many countries and regions. DST is not considered on some software systems at the beginning of their developments, for example, software systems developed in regions where DST is not observed. However, such systems may have to consider DST at the requests of their users. Before now, there has been no study about the impacts of DST on software development. In this paper, we study the impacts of DST on software development by mining the repositories on GitHub. We analyze the date when the code related to DST is changed, and we analyze the regions where the developers applied the changes live. Furthermore, we classify the changes into some patterns.

Automated program repair (in short, APR) techniques that utilize genetic algorithm (in short, GA) have a capability of repairing programs even if the programs require multiple code fragments to be changed. Those techniques repeat program generation, program evaluation, and program selection until a generated program passes all given test cases. Those techniques occasionally generate a large number of programs before a repaired program is generated. Thus, it is difficult to understand how an input program is evolved in the loop processing of genetic algorithm. In this paper, we are inspired by genealogy and propose a new technique to visualize program evolution in the process of automated program repair. We have implemented the proposed technique as a software tool for kGenProg, which is one of GA-based APR tools. We evaluated the proposed technique with the developers of kGenProg. In the evaluation, the developers found latent issues in kGenProg's processing and came up with new ideas to improve program generation. From those results, we conclude that our visualization is useful to understand program evolution in the APR process.

Browser-based volunteer computing (BBVC) is one of the distributed computing paradigms, attracting researchers' and developers' attention for its portability and extraordinary potential of computing power. However, BBVC still has two significant challenges: low programmability and performance. These challenges are a heavy burden for users and prevent BBVC from wide-spreading. In this paper, we propose a novel BBVC framework to solve the challenges by using MapReduce and WebAssembly. Our framework reduces the total execution time by 64% compared with a traditional BBVC mechanism. We also show a practical scenario and its performance.

In this paper, we introduce our tool, kGenProg, which is a new automated program repair system. kGenProg has several remarkable features. Thanks to the features, kGenProg got achieved high performance, high Extensibility, and high portability.

Automated program repair (in short, APR) has been attracting much attention. A variety of APR techniques have been proposed, and they have been evaluated with actual bugs in open source software. Currently, the authors are trying to introduce APR techniques to industrial software development (in short, ISD) to reduce development cost drastically. However, at this moment, there are no studies that report evaluations of APR techniques on ISD. In this paper, we report our ongoing application of APR techniques to ISD and discuss some barriers that we found on the application.

Coding style is a representation of source code, which does not affect the behavior of program execution. The choice of coding style is purely a matter of developer preference. Inconsistency of coding style not only decreased readability but also can cause frustration during programming. In this paper, we propose a novel tool, called StyleCoordinator, to solve both of the following problems, which would appear to contradict each other: ensuring a consistent coding style for all source codes managed in a repository and ensuring the ability of developers to use their own coding styles in a local environment. In order to validate the execution performance, we apply the proposed tool to an actual software repository.

In order to reduce software energy consumption, a lot of studies have been carried out focusing on the difference of implementation, such as API and algorithm. However, we hypothesize that there is a strong correlation between total energy consumption of a program and duration of its execution. If this hypothesis is correct, reducing energy consumption is equal to decreasing duration. Experimental results reveal that there is a strong positive correlation between them, and its correlation coefficient is higher than 0.9. We also find that memory usage is weakly correlated with total energy consumption. As a result, we conclude that if developers want to reduce software energy consumption, they should firstly decrease duration of execution, and secondly reduce memory usage.

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.

To fix various dependencies of application development using pass-by detection by a mobile device, we propose Pass-by Framework that handles data with standardization. In this study, we evaluate effects of performance of pass-by detection by differences in methods of implementation the sonar of Pass-by Framework. Therefore, we develop pass-by application using Bluetooth Low Energy as a first effort. We then conduct evaluation experiments for confirmation of change pass-by detection behavior depends on the difference of parameters.

As typically seen in Smart City, emerging technologies enable large-scale environment sensing using IoT devices deployed in a wide area. From the viewpoint of cost and efficiency, infrastructure of the large-scale environment sensing should be shared by multiple applications, with dynamically adapting the sensing behavior for different purposes. To achieve this, the infrastructure must implement a clever method that can command and control a lot of IoT devices in good order. To implement such multi-purpose large-scale environment sensing, we introduce an analogy of military system. Specifically, we propose a mission-oriented sensing with army hierarchy, where individual IoT devices and their dynamic purposes are regarded as soldiers and missions, respectively.

A number of reminder systems have been developed to help elderly people with dementia. However, the existing reminder systems lack the awareness of human context, the sympathetic human-machine interaction, and the flexibility of personal adaptation. To cope with the limitations, we are currently studying a new reminder service for people with dementia. Specifically, we exploit a BLE-based indoor positioning system to capture the current location and context of the patient. We then use a virtual agent system for rich interactions. Finally, we develop a schedule management system for personalized reminders. To integrate these heterogeneous systems, we re-design and deploy the systems as three services with Web-API: Location Service, Agent Service, and Schedule Service. These services are loosely integrated by Coordinator Service, based on the service-oriented architecture, In this paper, we first present the system architecture, and then discuss the key idea to implement the services. We also demonstrate “reminder at the entrance” as a practical scenario of the proposed services. In order to evaluate the Agent Service, which is a key component of proposed service, we have conducted the a preliminary experiment with 17 people with dementia.

The emerging indoor positioning systems (IPS) enable indoor location-aware applications (InL-App) within indoor space where GPS cannot reach. In most conventional systems, however, IPS and InL-App are tightly coupled, where one system cannot reuse location data or operation of other systems. This fact yields expensive development cost and effort of InL-App. To cope with the problem, this paper propose a cloud-based integration framework, called CIF4InL. With a common data model, CIF4InL integrates indoor location data obtained from heterogeneous IPS. It then provides application-neutral API for various InL-Apps. To evaluate the practical feasibility, we integrate two different IPS (RedPin and BluePin) using CIF4InL, where the applications transparently access the indoor locations gathered by two different IPS. Since CIF4InL allows the loose coupling between IPS and InL-Apps, it significantly improves reusability of indoor location information and operation.

This paper proposes a unified locating service, KULOCS, which horizontally integrates the heterogeneous locating services. Focusing on technology-independent elements [when], [where] and [who] in location queries, KULOCS integrates data and operations of the existing locating services. In the data integration, we propose a method where the time representation, the locations, the namespace are consolidated by Unix time, the location labels and the alias table, respectively. Based on possible combinations of the three elements, we then derive API for the operation integration.

Managing a home server within individual house is a major obstacle to practical use of home network system (HNS). Delegating the home server to a cloud is a promising approach. However, the conventional multitenant SaaS-based solution has the following risks among different households: security/privacy violation, failure propagation and insufficient resource demand. In this paper, we propose a novel cloud-based architecture for the home network system that achieves security isolation, fault isolation and resource isolation. Specifically, we first create a virtual home server for every household using IaaS. On top of every virtual home server, we then create additional virtual machines, each of which contains a single service or application. Finally, using dynamic scaling, we allocate resources needed for individual virtual home servers. Based on the idea, we construct the proposed architecture by three layers: HNS Lite, House Cloud and Service Provider.

The goal of this paper is to find an answer that how remote monitoring sensor should be accurate. To achieve the goal, we propose three methods, generalization by three-actor model, design the algorithm of the three-actor and development of RMS simulator. With the three-actor model, we can generalize RMS by interactions among three actors. As the second step, we design the algorithms that how to work the actor in RMS. So we could express how often the elderly become ill. Moreover, using the developed simulator, we could simulate with many patterns of conditions. The result of simulations shows that if the accuracy of the sensor is greater than 0.9990, then the RMS has much more detectionPower.

Modern cloud services and machine-to-machine (M2M) systems provide various kinds of data via various Web services. Implementing context-aware services integrating such global data are promising in various applications. However, it has been challenging to manage heterogeneous contexts and services defined in various Web services. To cope with this, we design a framework, called RuCAS, which systematically manages every context-aware service in form of ECA (Event-Condition-Action) rule. We also develop RuCAS platform, which publishes API of RuCAS as Web service. Using the RuCAS platform, users can define their own contexts with various Web services (e.g., information service, sensor services, networked appliances, etc.). Based on the defined contexts, they can create ECA rules to define custom context-aware services. To support users, We also implement a GUI front-end of RuCAS platform, called RuCAS.me. RuCAS.me supports users even if the users are non-expert. A case study in a real home network system demonstrates practical feasibility of RuCAS platform and RuCAS.me. The contribution of this paper is to provide design and implementation details of RuCAS, by which one can fully understand systematic management of context-aware services with Web services.

In order to achieve intuitive and easy operations for home network system (HNS), we have previously proposed user interface with virtual agent (called HNS virtual agent user interface, HNS-VAUI). The HNS-VAUI was implemented with MMDAgent toolkit. A user can operate appliances and services interactively through dialog with a virtual agent in a screen. However, the previous prototype heavily depends on MMDAgent, which causes a tight coupling between HNS operations and agent behaviors, and poor capability of using external information. To cope with the problem, this paper proposes a service-oriented framework that allows the HNS-VAUI to provide richer interaction. Specifically, we decompose the tightly-coupled system into two separate services: MMC Service and MSM service. The MMC service concentrates on controlling detailed behaviors of a virtual agent, whereas the MSM service defines logic of HNS operations and dialog with the agent with richer state machines. The two services are loosely coupled to enable more flexible and sophisticated dialog in the HNS-VAUI. The proposed framework is implemented in a real HNS environment. We also conduct a case study with practical service scenarios, to demonstrate effectiveness of the proposed framework.

A home network system (HNS) provides value-added services for home users by networking house-hold appliances and sensors. In the conventional architecture, the HNS appliances and services are tightly coupled. It is therefore difficult for users to freely choose their favorite appliances and services. In this paper, we propose a new HNS architecture that accommodates multi-vendor services by extensively using cloud technologies. The new architecture manages individual HNS operations and data as standard services within the cloud. The vendor services must go through the cloud to access the HNS. Thus, loose coupling among the HNS and services can be achieved. As a result, the proposed architecture realizes more flexible HNS beneficial for both users and vendors.

With the spread of Machine-to-Machine (M2M) systems and cloud services, various kinds of data are available through Web services. A context-aware service recognizes a real-world context from such data and behaves autonomously based on the context. However, it has been challenging to manage contexts and services defined on the heterogeneous and distributed Web services. In this paper, we propose a framework, called RuCAS, which systematically creates and manages context-aware service using various Web services (e.g. information services, sensor services, networked appliances, etc.). The framework describes every context-aware service by an ECA (Event-Condition-Action) rule. For this, an event is a context triggering the service, a condition is a set of contexts to be satisfied for execution, and the action is a set of Web services to be executed by the service. Thus, every context-aware service is simply managed in a uniform manner. Since the RuCAS is published as a Web service, it is easy for various applications to reuse and integrate created contexts and services. As a case study, RuCAS is applied to creating context-aware services in a real home network system.

Smart city provides various value-added services by collecting large-scale data from houses and infrastructures within a city. To use such large-scale raw data, individual applications usually take expensive computation effort and large processing time. To reduce the effort and time, we propose Materialized View as a Service (MVaaS). Using the MVaaS, each application can easily and dynamically construct its own materialized view, in which the raw data is cached in an appropriate format for the application. Once the view is constructed, the application can quickly access necessary data. In this paper, we design a framework of MVaaS specifically for large-scale house log, managed in our smart-city data platform Scallop4SC. In the framework, each application first specifies how the raw data should be filtered, grouped and aggregated. For a given data specification, MVaaS dynamically constructs a MapReduce batch program that converts the raw data into a desired view. The batch is then executed on Hadoop, and the resultant view is stored in HBase. We conduct an experimental evaluation to compare the response time between cases with and without the proposed MVaaS.

To support mashup of heterogeneous lifelog services, we have previously implemented the lifelog common data model (LLCDM). The previous LLCDM was implemented with MySQL, where various types of application-specific data (e.g., numeric values, text, JSON or XML) were all stored in a column in a schemaless text format. Any query with application-specific data had to be managed by individual applications. It had also a scalability issue as the data size grew.

On the software development PBL (SDPBL), the implementation of firmly-fused development environment for students and monitoring environment for teachers are required in order to succeed in education. We have proposed the service, named "DaaS BADER" in compliance with demands from practical teachers to decrease the cost for preparation and maintenance of unified exercise environment and to monitor the progress of projects by teachers. In this paper, we have reported knowledge and information obtained by practical SDPBL and feedback contents for a student or group given by monitoring environment. Then, we have discussed the effectiveness of DaaS BADER from these results.

Smart city provides various value-added services by collecting large-scale data from houses and infrastructures within a city. However, it takes a long time for individual applications to use and process the large-scale raw data directly. To reduce the response time, we use the concept of materialized view of database. For a given requirement of an application, the proposed method constructs a materialized view for caching the application-specific data. In this paper, we especially develop a method that uses MapReduce for large-scale power consumption data stored in HBase KVS. We conduct an experimental evaluation to compare the response time between cases with and without the materialized view. As a result, the proposed method with materialized view is effective especially when application repeatedly access the same data, or when the application-specific data is derived from a large set of raw data.

We have proposed a framework named SO-MSR: service-oriented mining software repository, which applied service oriented architecture to MSR. Following the SO-MSR, we have developed a web service, named MetricsWebAPI, for metrics calculation from a variety of software repositories and a variety source codes. In this paper, we develop and propose Metrics Viewer, which is client of Metrics Viewer and is a web application to support personal process improvement. Metrics Viewer provides an interactive user interface for repository file exploring. Moreover the Metrics Viewer visualizes change of source code metrics to support overhead view of personal process. End user can improve their development activities based on software repository data without MSR specific knowledge by using Metrics Viewer. We have conducted a pilot study to evaluate the effect of proposed system for personal process improvement.

Visualizing energy consumption is a useful method that prompts people to perform energy-saving behaviors. Many systems for the energy visualization come onto the market. Since purposes and attitudes to energy saving vary among individuals, it is difficult to satisfy all users by static ready-made visualization. To cope with the problem, this paper presents Personalized Energy Visualization Service (PEVS), which dynamically generates appropriate visualization for individuals based on preferences. PEVS extracts user's requirement with a questionnaire wizard. We design the questionnaire in a goal-oriented fashion, from viewpoints of term, unit and scope. We then consider how to select an appropriate graph from the answer of the questionnaire. An experimental evaluation shows that every subject was able to create a unique personalized visualization easily.

Electricity peak shaving is a promising approach to energy saving at home. The conventional peak shaving has been conducted in an automatic and system-centric approach, using the emerging home energy management systems (HEMS). However, for more sustainable energy-saving, it is also important to develop a human-centric approach, which encourages residents to perform energy-saving behaviors by themselves. In this paper, we present a smartphone application, named Peak Cutter, which assists home users to perform spontaneous peak shaving. Cooperating with a home network system, Peak Cutter monitors electricity demand in a house, and notifies the user via a smartphone when the demand exceeds a threshold. The user then checks the current energy consumption of each home appliance, and can remotely turn off some appliances to shave the peak. We have also conducted an experiment, where five subjects tried to save energy of our laboratory using Peak Cutter. It was shown that a certain amount of energy was reduced within the one-week experiment, and that Peak Cutter promoted energy-saving attitudes of most of the subjects.

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.

Smart city is a next-generation city planning. In the smart city, some value-added services such as energy saving and optimization of traffic are provided using wide variety of logs collected from various appliances and sensors. We are currently developing a smart city platform, called Scallop4SC, which supports collecting and processing the extremely large-scale log data. This system stores variety of logs on the HBase key-value store, and supports powerful data processing by Hadoop MapReduce. The goal of this paper is to propose service API of Scallop4SC. The API should be implemented as a Web service, which allows heterogeneous clients to access large-scale log (of energy, device and environment), as well as house configuration data of the smart city. In order to cover queries from a variety of applications, we design possible combinations of service type, data type, access type and queries, based on practical service scenarios. As a case study, we present concrete smart city services for energy saving and quality of life improvement. Then, we evaluate how the proposed API can implement these practical services.

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.

The human interface devices for the home network system (HNS) should be flexible enough to reflect individual preferences and lifestyles of home users. To fill the requirement, this paper presents a novel framework that enables Personal Home Controllers (PHC) on smartphones. The proposed framework is designed so that a user can freely design screen layouts with buttons and pictures, and can define favorite HNS operations on the layouts. The first part of our contribution is PHC Framework, which dynamically implements a PHC based on a given user definition. The second part is PHC Creater, a GUI application which supports the user to create the user definition. The proposed framework is implemented for Android mobile devices. We conduct an experimental evaluation, where subjects create PHCs for operating an actual HNS. The experimental result shows that every subject creates a unique PHC with his favorite motif, and that most subjects find usefulness and pleasure in creating their own PHCs.

In this paper, we try to empirically characterize user's habituation effect of the voice control in the Home Network System (HNS). We propose three kinds of metrics that capture the user's habituation quantitatively: (M1) the time of system speech, (M2) the number of support commands and (M3) the number of mistakes. The experimental results show that the metrics M1 and M2 are reasonable to capture the habituation of the user.

In the future ubiquitous network, it is expected to realize an adaptive service platform, which dynamically integrates various service resources to provide adaptive and context-aware services. This paper presents a service registry, called UBI-REGI, in order to support efficient and dynamic discovery of service resources in the ubiquitous network.

In order to support efficient integration of heterogeneous lifelog services, we have previously proposed a lifelog mashup platform consisting of the lifelog common data model (LL-CDM) and the lifelog mashup API (LLAPI) to access the standardized data. However, it had the performance bottleneck, and was poor in the portability. To cope with these problems, we re-engineer the LLCDM and the LLAPI with the relational database MySQL and the Web services, respectively. Furthermore, we evaluate the practical feasibility through an actual development project.

In this paper, we design and implement a consumer-oriented service platform called ReceiptLogService to store and use their receipt log by consumers. ReceiptLogService assumes receipt data as a lifelog. The receipt lifelog may provide gaining awareness of economic for consumers. We also develop a social network Web application called ReciLog that extensively uses the ReceiptLogService platform. ReciLog extensively supports every end user to review daily life from financial and living aspects. We then conducted an experimental evaluation of the ReciLog with actual subjects. The experimental results showed that it was interesting and useful for end users to review and share the receipt log.

Mining software repository is one of important topic in empirical software engineering. A wide variety of mining tools are published on the Web and we can easily apply individual mining approaches. However, there is no supporting system for sharing the mining techniques, procedures, knowledge and know-how. This sharing problem also poses great difficulties for independent validation and experimental replication from mining researchers. The goal of this paper is to provide a framework that supports sharing the repository mining techniques for reducing mining effort and external validation of analysis results. This paper proposes Service Oriented Framework for Mining Software Repository (SO-MSR) which applied Service Oriented Architecture (SOA) to the repository mining. Following the SO-MSR, we also develop Metrics Web API which is a prototype system for metrics measurement. Metrics Web API can measure a variety of source code metrics without relying on any types of repositories and programming languages. The proposed system is designed and implemented as a Web service and demonstrated using actual software repository.

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.

This paper presents a framework that integrates different kinds of lifelog services. For efficient data mashup, we first propose the lifelog common data model (LLCDM), which normalizes data structures and formats of heterogeneous lifelog records. We derive application-neutral data items by an interrogative analysis of what, why, when, who, where and how. We then implement the lifelog mashup API (LLAPI) to achieve standardized access to heterogeneous lifelogs. A case study of integrating practical lifelog services (Twitter, Flickr and GARMIN Connect) demonstrates the effectiveness of the proposed framework. It was shown that the development effort with the proposed APIs was reduced to 11.9%, compared to the conventional mashup development with the proprietary APIs.

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.

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 F1-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).