Hyung-Min Koo

A repository framework for self-growing robot software

Self-growing software is a software system that grows its functionalities and configurations by itself based on dynamically monitored situations. Self-growing software is especially necessary for intelligent service robots, which monitor their surrounding environments and provide appropriate behaviors for human users. Intelligent service robots often face problems that cannot be resolved with the conventional software technology. To support self-growing software for intelligent service robots, the SemBots project at ICU is developing a repository framework that allows robot software to dynamically acquire software components that are necessary to resolve a dynamic situation. In this paper, we describe the requirements and architecture of the repository system for self-growing software. We also present a prototype implementation of the repository system.

User-Centric Web Services for Ubiquitous Computing

One of the key issues in ubiquitous computing environments is to realize user centricity, which is about enabling Web-based services and services in general to be prepared, supported and delivered from the perspective of users rather than system elements. To accomplish user centricity, it is essential to deal with the high-level goals of multiple users and with dynamic changes of contextual information. The approach of task-oriented computing is a means of realizing a user-centric service provision in Ubiquitous Computing environments. This approach represents users’ goals in tasks, which are then bound to available service instances. This chapter describes the essential requirements for a user-centric service provision in Ubiquitous Computing environments. User centricity, context awareness, composability and dynamicity are such requirements. Existing works regarding service provision in Ubiquitous Computing are analyzed by highlighting their limitations in the light of those requirements. This chapter also describes a service framework for Ubiquitous Computing. This framework consists of three layers - the task layer, the composition-pattern layer and the service layer. The essential semantic elements that describe a task are arranged in a task description model. That model is used by a semantically based mechanism to select appropriate tasks based on context information. It is also utilized by a pattern-based service composition mechanism. The framework is illustrated by a demo application example developed in our test bed. By leveraging the task-oriented computing approach, this chapter contributes to enhancing the reusability of tasks and patterns, improving flexibility when developing Ubiquitous Computing applications and providing dynamism to the service provision in this type of environments.

An Analysis of Problem-Solving Patterns in Open Source Software

Open Source Software (OSS) has become an important environment where developers can create, exchange, and improve reusable software assets by collaborating with other developers. Although developers may find useful software assets to reuse from OSS for their projects, they usually experience difficulties in solving problems that occur while integrating the assets to their own software. We investigated data from major open source environments such as Sourceforge.net and GitHub, and learned that there is a common pattern of solving reuse-related problems in OSS. To analyze the pattern in detail, we have developed an ontological model to formally represent the symptoms and causes of the reuse-related problems, and the correlations between them. Based on this model, we collected data from Sourceforge.net, and built a knowledge base for the most common problem type. We extracted the core types of symptoms and causes for the problem type and calculated the number of correlations between the types of symptoms and causes. We found that there exist correlations between the symptoms and causes that are extracted from the discussion threads for the problem type, and about 60% of them are statistically significant. We also conducted a study to understand the effective timing of recommending solutions to the developers by analyzing the recall rates of finding the causes of the problems in a timeline. We figured that most of the important causes of a problem are discussed at the beginning of the forum discussion. This leads us to the conclusion that recommending the causes of a problem early by using our knowledge framework may help developers spend less amount of time to solve the problem (around 50% less time than solving the problem without using our framework).

A Cell-Based Approach for Evolutionary Component Repositories for Intelligent Service Robots

Self-growing software is a software system that grows its functionalities and configurations by itself according to dynamically monitored situations. A component repository system is one of the essential parts of self-growing robot software, and the SemBots project at ICU is developing a cell-based distributed repository system that reconfigures its structure dynamically for reflecting accessibility evolutionarily. To accomplish evolutionary repositories, we invent the concept of a cell that is a logical grouping of distributed repositories based on an ontology hierarchy. In addition, it is also a unit for evolutionary reconfiguration of the repository structure. In this paper, we describe the requirements and architecture of the cell-based repository system for self-growing software. We also present a prototype implementation and experiment of the repository system. Through the cell-based repositories, we achieve improved performance of self-growing actions for robots and efficient management of components for developers.

Construction and utilization of problem-solving knowledge in open source software environments

Abstract Open Source Software (OSS) has become an important environment where developers can share reusable software assets in a collaborative manner. Although developers can find useful software assets to reuse in the OSS environment, they may face difficulties in finding solutions to problems that occur while integrating the assets with their own software. In OSS, sharing the experiences of solving similar problems among developers usually plays an important role in reducing problem-solving efforts. We analyzed how developers interact with each other to solve problems in OSS, and found that there is a common pattern of exchanging information about symptoms and causes of a problem. In particular, we found that many problems involve multiple symptoms and causes and it is critical to identify those symptoms and causes early to solve the problems more efficiently. We developed a Bayesian network based approach to semi-automatically construct a knowledge base for dealing with problems, and to recommend potential causes of a problem based on multiple symptoms reported in OSS. Our experiments showed that the approach is effective to recommend the core causes of a problem, and contributes to solving the problem in an efficient manner.

An Interaction-Pattern-Based Approach to Prevent Performance Degradation of Fault Detection in Service Robot Software

In component-based robot software, it is crucial to monitor software faults and deal with them on time before they lead to critical failures. The main causes of software failures include limited resources, component-interoperation mismatches, and internal errors of components. Message-sniffing is one of the popular methods to monitor black-box components and handle these types of faults during runtime. However, this method normally causes some performance problems of the target software system because the fault monitoring and detection process consumes a significant amount of resources of the target system. There are three types of overheads that cause the performance degradation problems: frequent monitoring, transmission of a large amount of monitoring-data, and the processing time for fault analysis. In this paper, we propose an interaction-pattern-based approach to reduce the performance degradation caused by fault monitoring and detection in component-based service robot software. The core idea of this approach is to minimize the number of messages to monitor and analyze in detecting faults. Message exchanges are formalized as interaction patterns which are commonly observed in robot software. In addition, important messages that need to be monitored are identified in each of the interaction patterns. An automatic interaction pattern-identification method is also developed. To prove the effectiveness of our approach, we have conducted a performance simulation. We are also currently applying our approach to silver-care robot systems.