Izuru Kume

Robot navigation in corridor environments using a sketch floor map

This paper presents a new robot navigation system that can operate on a sketch floor map provided by a user. This sketch map is similar to floor plans as shown at the entrance of buildings, which does not contain accurate metric information and details such as obstacles. The system enables a user to give navigational instructions to a robot by interactively providing a floor map and pointing out goal positions on the map. Since metric information is unavailable, navigation is done using an augmented topological map which described the structure of the corridors extracted from a given floor map. Multiple hypotheses of the robots location are maintained and updated during navigation in order to cope with sensor aliasing and landmark-matching failures due to factors such as unknown obstacles inside the corridors.

Toward Comprehension of Side Effects in Framework Applications as Feature Interactions

Application frameworks are widely used in order to increase efficiency and reliability in object-oriented software development. In this paper we put a focus on side effects caused by misuse of frameworks. A processes of such a side effect often includes cross-border method invocations between an application and its framework, and is difficult to resolve. This paper proposes an approach to visualizing such a side effect as a feature interaction between a framework and its application. This paper shows a case study to apply our approach to a practical framework application, and discuss its practical usefulness.

A practice of collaborative project-based learning for mutual edification between programming skill and artistic craftsmanship

It is well known that using computer games as educational materials for computer programming and software engineering education effectively motivate students. For this purpose in Konan University, we have practiced project-based learning to develop game programs. From instructional practice in Konan University to date, we concluded that we need more specialized game contents in order to better motivate the students. On the other hand, in character design training in Osaka University of Arts, it has been expected that showing students a goal where their characters are animated in game system effectively motivates the students. However, to develop game system, high level programming skill is needed. To address these problems, we propose a collaborative project-based learning approach which can be practiced in cooperation with a faculty of computer science and a faculty of arts. In the learning process, program codes are developed by the computer science students and game contents are created by the arts students. The process also includes online meetings to coordinate their work. Through the project, students would not only improve their expertise but learn unprofessional knowledge, experience collaborative work and improve communication skill. In the last year, we have practiced the collaborative project-based learning to develop a 3D fighting game in cooperation with Konan University and Osaka University of Arts. In this paper, we will report the practice and evaluate its educational effectiveness by student questionnaires about the learning and examinations about software engineering.

A Case Study of Dynamic Analysis to Locate Unexpected Side Effects Inside of Frameworks

Recently many frameworks are deployed without proper documents to explain their correct usage. In the absence of proper documents, application developers often write code to call a framework API in a wrong way. Such a wrong API call tends to bring about a failure after its complex chain of infection inside of a framework. The complexity and the lack of implementation knowledge about a framework make it difficult for application developers to debug this kind of failure. In the preceding study the authors focused on unexpected side effects that are caused by wrong API calls and bring about failures, and developed a dynamic analysis technique to detect such side effects. In this paper, the authors introduce a case study to find a wrong API call using our technique. A Case Study of Dynamic Analysis to Locate Unexpected Side Effects Inside of Frameworks

Identifying Mandatory Code for Framework Use via a Single Application Trace

Application frameworks allow application developers to effectively reuse both designs and implementations which frequently appear in their intended domains. However, when using a framework with large scale APIs, its usage to implement an application-specific behavior tends to be complicated. Thus, in practice, application developers use existing sample application code as references for their development, but the task to locate the parts which are related to their application usually becomes a burden. To address this problem, in this paper, we characterize the problem as a kind of dynamic flow analysis problem, and based on the characterization, we present a method to automatically identify the mandatory code for the framework use using only a single sample applications trace. We have conducted case studies with several real-world frameworks to validate our method and the results indicate that the method is suitable to extract the mandatory framework usage.

A Method for Early Detection of Mismatches between Framework Architecture and Execution Scenarios

Recently, application frameworks are widely used to facilitate software development. However in a real-world application development, potential mismatches between a selected framework and the applications specification often remain undetected until late in the development process. Especially if an architecture level mismatch between them is left unresolved, then enormous implementation level effort to suppress the mismatch and/or modification of the frameworks internal implementation would be needed. To avoid the problems, we present a method to detect architectural mismatch between a selected framework and the execution scenarios of the application to develop before its implementation process. In this paper, we have evaluated two 3D game frameworks using our method for a case study, and have identified several problems to implement a certain game application.

Toward a dynamic analysis technique to locate framework misuses that cause unexpected side effects

Recently many frameworks are used in software development without proper documentation, and are misused by application developers in calling framework APIs. Debugging a failure caused by a wrong API call is difficult and requires a proper supporting technique. In our preceding study we developed a dynamic analysis technique to detect possibly unexpected side effects that cause failures. In this paper, we introduce a case study to identify a wrong API call using this technique.

A Feature Model of Framework Applications

Learning how to use application frameworks effectively becomes important in their widespread use in software development. Learning frameworks is often difficult because of lack of their documentation and their complexity. In order to help framework learning, we propose a behavioral model, called feature component model, which abstracts internal behaviors of framework applications in terms of their behavioral characteristics such as inversion of controls. We apply our behavioral model to an example misuse of a practical framework developed by a third party in order to show its practical usefulness.

An OOAD approach to resolve conflicting management of shared objects among components

Component-based development is an important and a practical topic of software engineering. Objectoriented analysis and design (OOAD) approach, and component-based development go particularly well together because the former provides software architecture that increases the merit of component-based development. However, Components that work well independently do not always work correctly. Often, it is because unwilling dependencies among the components are introduced. In this paper we study a kind of dependency caused by inconsistent management of objects that are shared by several components. We propose an OOAD approach to specify disciplined management of shared objects.