We verify the effectiveness of the COINS by implementing the machine description for the Alpha Architecture. For this purpose, we demonstrate the detail process of the Alpha TMD implementation in accordance with time. And we show that machine description of the new target architecture is easily obtained. Then, we compare the performance of the COINS with GCC. We conclude that the COINS is acceptable since it is only 25% slower than GCC on average. Based on these experiences, we summarize a way to develop a new COINS machine description for a short period of time.
There have been many studies on question-answering systems on the Web. Some of them try to find the answers to “Who”, “When” and “Where” type questions. However, there are few studies on practical systems which allow “Why” type questions. Because “Why” type questions need sentences for the answers and traditional and typical methods give the answers as a phrase or a word. Therfore we have proposed and implemented a prototype system “RE:Why” for extracting answers to a “Why” type question. RE:Why adopts new method which pays attention to the structual relations between sentences of a question and sentences of the answer on the Web. We have conducted experiments using twenty questions and have compared the performances between RE:Why and a traditional keyword search engine by measuring precisions and recalls.
A live video of a room shows a kind of presence information of the member in the room. It can be used to facilitate casual communication among distributed group members. However, only a live video image is not enough because it does not show future and past information. Therefore, we designed and implemented the KokaCam system that visualizes presence information on a live camera image using comic techniques. KokaCam uses live camera images as a basis for representing virtual shared space for a small community. Presence information—activities of users—is visualized as ‘fire’, ‘smokes’, and effect lines, and superimposed at the seat of each member in the room, which makes easy to understand the mapping between presence information and the corresponding members. We have installed the KokaCam system at several dispersed rooms in our university as a communication tool, and evaluated it informally.
This paper proposes a supporting system for browsing, editing and sharing experiences captured in the events such as research exposition and museum touring. The aim of the system is to facilitate users to edit and share their experience data—sets of video data captured in multiple viewpoints—by enabling the users to manipulate the data easily. Our system consists of two parts. The first part is to show the users automatically summarize the experience data by converting segmented video scenes into so-called animated cartoons, i.e., sets of snapshots representing the scenes. The second part is to facilitate the users to edit their experience data by showing the whole experience data with layout of scenes like comics. The system is a Web-based system for the users to easily browse and edit their experiences.
Skeletal parallelism encourages us to develop parallel programs by composing ready-made components called parallel skeletons. In this paper, we propose a parallel implementation of XPath queries by using parallel tree skeletons. Since the parallel tree skeletons are implemented efficiently in parallel for trees of any shape, our implementation of XPath queries has demonstrated good scalability even for the ill-balanced XML trees.
Recent complicated software functions have made it difficult for end users to operate them. Thus, it becomes important to learn how to operate them easily and effectively. Employing a tutorial system is the most suitable approach for learning how to operate software functions. A tutorial system demonstrates how to operate using the actual software. However, development of tutorial systems requires much time and costs. Therefore, we propose a method of generating tutorial systems based on use case diagrams, sequence diagrams and test cases. In our method, a generated tutorial system shows function names extracted from use case diagrams, how to operate along with sequence diagrams, and text string input and item selection using data from test cases. We evaluate the burden placed on developers by the requirement of generating tutorial systems and whether the tutorial system generated by our method performs software operation correctly.
We present the Prolog Cafe system that translates Prolog into Java via the WAM. Prolog Cafe has the advantages of portability, extensibility, and smooth interoperation with Java. Prolog Cafe provides multi-threaded Prolog engines. A Prolog Cafe thread seems to be conceptually an independent Prolog evaluator and communicates with each other through shared Java objects. From the Java side, the translated code of Prolog Cafe can be easily embedded into Java applications such as Applets and Servlets. From the Prolog side, any Java object can be represented as a Prolog term, and its methods and fields can be exploited from Prolog. We also give a brief introduction to the Multisat system, a parallel execution system of SAT solvers, as an application of Prolog Cafe.
We propose a state-based task recognition method that realizes to recognize complex tasks including erroneous user operation and/or parallel operation. In our approach, we define a task as a set of a target object and initial and final state of user's task. The task recognition is achieved by comparing these state definitions and a state transition history that made by a sequence of user operation. We can appropriately recognize user's task by using this approach without a predefined complete task model like conventional approaches, even optional and/or erroneous operations are included in a user's operation sequence. We also explain a task recognition system implemented on Emacs to show the usefulness of our approach in solving task recognition problems of conventional intelligent help systems.
The spread of the Internet and the advanced use of the Internet increase the opportunity of the implementation of communication protocols. A communication protocol generally comprises definitions of message formats and rules for message sequences. Therefore a programmer needs to implement parsing received message, building sending messages, timeout processing, using asynchronous I/O, and so on. Although most of them are routine work, they are complicated, so maintainability of the program gets worse, and they tend to cause bugs besides. In this paper, we describe the Preccs compiler that generates C code from the description of the communication protocol. In Preccs, the message format is described with the extended regular expressions, and the message sequence is described with the notation based on the process calculus. The Preccs compiler automatically generates C code along with these descriptions. Consequently programmers are released for complicated programming work, and they can rapidly develop communication software with high reliability and maintainability.
This paper proposes test-based pointcuts, a new pointcut mechanism for aspect-oriented programming (AOP). In AOP languages, the programmer must specify points to which an aspect is applied. In existing AOP languages, pointcuts have frequently to be updated even when minor modification is made to a program because the pointcuts rely on method and type names in the program. With test-based pointcuts, the programmer can indirectly specify points of aspect application through test programs. Thus it does not need to change pointcut descriptions as long as the test programs are updated in response to the program modification. Also, test-based pointcuts can specify points of aspect application by matching on execution history against execution histories of tests. Thus it gives more straightforward descriptions than those specify points of aspect application based on low-level control-flow such as conditional branches. Our case study with test-based pointcuts confirmed that, in most cases, more robust than existing pointcuts in AspectJ.
A software system developed by object-oriented programming operates by message exchanges among the objects allocated by the system. To understand such system behavior we need to grasp how the objects are communicating. However, it is difficult to understand the behavior of such system, since it has many elements determined dynamically, and many objects are usually related to one functionality. We propose a method of extracting a sequence diagram from an execution trace of a Java program in order to understand the behavior of the program. Our method compresses a repetition included in the execution trace. The compressed execution trace is shown as a sequence diagram. This paper presents four compression rules designed for object-oriented program. The experiment illustrates how our rules effectively compress the execution trace and extract a sequence diagram from the result.