A Diagnosis explains why a program fails. Making a correct diagnosis is necessary for debugging a practical program, but it requires many efforts to comprehend the program. Supporting program comprehension for making a diagnosis is thus very important Maintainers usually try to comprehend their programs by interacting with debugging tools that permit access to runtime information. These tools should be evaluated based on how they help maintainers' comprehension during the interactions with them. However, most tools are evaluated based only on the final results of maintenance tasks. We are currently developing a method to evaluate the contribution of a supporting tool to a maintainer's internal comprehension process based on the relevance to finding the chain of infection. The relevance is calculated using the trace analysis technology we have developed. In this paper we explain the overview of our evaluation method, and shows its validation by an exploratory experiment.

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.

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.

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.

Dynamic mixin is a construct available in Ruby and other dynamic languages. It can be used as a base to implement a range of programming paradigms, such as dynamic aspect-oriented programming and context-oriented programming. However, the performance characteristics of current implementation of dynamic mixin in Ruby leaves much to be desired under condition of frequent dynamic mixin operations, global method cache and inline cache misses incur significant overhead. In this work we implemented fine-grained state tracking for CRuby 1. and were able to improve performance by more than six times on the microbenchmark exercising extreme case flowing 4 times to global method cache clearing, 28% to fine-grained state tracking and further 12% to inline cache miss elimination by caching alternating states. We demonstrated a small application using dynamic mixins that gets 48% improvement in performance from our techniques. We also implemented in C a more general delegation object models and proposed an algorithm of thread-local caching, which allows to reduce inline cache misses while permitting thread-local delegation changes.

We present the migratory cursor, which is an interactive interface that enables users to move a cursor to any desired position quickly and accurately using voice alone. The migratory cursor combines discrete specification that allows a user to specify a location quickly, but approximately, with continuous specification that allows the user to specify a location more precisely, but slowly. The migratory cursor displays multiple ghost cursors that are aligned vertically or horizontally with the actual cursor. The user quickly specifies an approximate position by referring to the ghost cursor nearest the desired position, and then uses non-verbal vocalizations to move the ghost cursors continuously until one is on the desired position. The time spent using the continuous specification which is slow to use is short, since it is used just for fine refinement. In addition, the migratory cursor employs only two directional movements: vertical and horizontal, so that the user can move it quickly to any desired position. Moreover, the user can easily and accurately stop cursor movements by becoming silent when the cursor reaches the desired position. We tested the usefulness of the migratory cursor, and showed that users could move the cursor to a desired position quickly and accurately.

This paper describes an extension of our previous technique for making 2D animation by drawing effect lines, which is a popular technique that represents motions and emotions in cartoons. It incorporates multi-step effect lines in one keyframe and constraints on the motions of objects. The new features improve the user's expressive power for specifying 2D animation interactively.

When we create 2D animations on a desktop computer using programs such as Microsoft PowerPoint or Macromedia Flash, we assign effects to objects and define their parameters, such as their path, speed, and time of movement. To do this, we use conventional interfaces like menus or dialog boxes. However, the motion effects associated with each object are not displayed on the canvas explicitly, so the user-can investigate the properties of each object only by opening a dialog box to see the animations that are associated with the object. Moreover, setting various parameters using menus and dialog boxes is time-consuming because the user must set each parameter individually. We have therefore developed a method that uses an effect line to set each effect and its parameters. Effect lines are a popular technique that is used in comics and cartoons. They depict information on the effects of an object, such as its speed, length of path, and degree of rotation. They enable us to set effects using simple gestures. In addition, the effect lines can be combined. That is, the effects each effect lines have are merged. The feature makes effect lines flexible for the users to create various animations. Effect lines enable the user to recognize animation by displaying the effect lines on each keyframe during on-screen editing. We have developed a prototype animation authoring system. On this system, the user can create various animations with effect lines. We have evaluated the effectiveness of our method as visual input method and pictorial output method, and have discussed about it. The user can set most of "start effect" of PowerPoint by using effect lines

We propose 'Trace View', a static visualization method for monitoring and debugging the dynamic behavior of programs written in dataflow visual programming languages. Trace View presents a hierarchical structure of the dataflow between nodes that is created over the execution time of the program. The view also serves as an interface that allows the programmer to select a data stream link when data must be examined during debugging. Moreover since visualization grows in size according to the life time of the program, we have developed techniques to scale the view using a multi-focus focus+context view.

This paper proposes a technique for generating more comprehensible animations from discussions, which are often hard to follow, in USENET. This technique consists of two steps. In the first step, our prototype system generates a scenario from articles in a news thread using the quote relationship. In the second step, it generates an animation based on the scenario, casting 3D avatars as the authors of the articles. We also implemented a prototype system based on this technique and made several animations from articles posted to USENET.

Multi-focus distortion-oriented views are useful in viewing large information on a small screen, but still have problems in managing multiple foci during editing. The user may have to navigate information space by focusing and defocusing multiple parts to obtain multi-focus layouts that change according to various editing situations. As a result, it becomes haphazard to navigate and edit large nested networks such as hypertexts. We propose a user interface for quickly obtaining desirable layouts. The interface uses two techniques: focus size prediction and predictive focus selection. These techniques are based on a user test and experiences in applications. We also describe two example applications.

A design and verification technique for implementation schemes of distributed software is presented. In this technique, first, the specification is modelled by a concurrent object system, that is, one which is constituted of computational agents with capability of concurrent execution and message passing. Then, such a concurrent object system is transformed into another concurrent object system, which models a sophisticated implementation scheme.

An object-oriented computation model is presented which is designed for modelling and describing a wide variety of concurrent systems. In this model, three types of message passing are incorporated. An overview of a programming language called ABCL/1, whose semantics faithfully reflects this computation model, is also presented. Using ABCL/1, a simple scheme of distributed problem solving is illustrated. Furthermore, we discuss the reply destination mechanism and its applications. A distributed “same fringe” algorithm is presented as an illustration of both the reply destination mechanism and the future type message passing which is one of the three message passing types in our computation model.