Software product line development (SPLD) is the development in that assets are systematically reused and therefore software can be efficiently developed. However, verification cost can easily increase in software development. Hence, the verification in SPLD is important; how to verify huge number of potential products, how to verify reusable assets, and so forth. In this paper, we describe current trends of verification techniques for software product line, especially testing and verification with formal methods.
This paper quantifies the difficulty of program analysis based on the information theory. The basic idea is to consider that a program is ultimately obfuscated if instructions appear at random; that is, (1) all instructions has an equal frequency of appearance, and (2) there is no pattern observed in the instruction sequence. We quantified (1) based on the entropy and (2) based on the Kolmogorov complexity. We evaluated the feasibility of our proposal through a case study.
Model driven engineering (MDE) is a set of well defined practices based on tools that use at the same time metamodeling and model transformations, to achieve some automated goals in the production, maintenance or operation of software intensive systems. Although there are a substantial amount of literature on individual technique, it has been difficult to find one that gives a birds eye view on MDE that also covers entire history and background. This series of articles are based on the intensive course given at the National Institute of Informatics by Jean Bézivin who has been leading the field of MDE. We will introduce the history of modeling languages, theories, basic principles, applications and prospects of MDE. In this first article, we will have a look at the past history of modeling languages, and introduce fundamental concepts of MDE.
In a general GUI environment, it is difficult to detect an object that a user wants to look at. However, detecting objects within the non-gaze area is easy, and using this region enables us to perform a new interaction. In this paper, we propose a fast target-pointing technique using the non-gaze area. The cursor speeds up in the non-gaze area for fast pointing and slows down to normal speed near the gaze point for fine-grained pointing. In a square-clicking experiment, we compared the selection time and the error rate at three cursor speed settings: the default and the maximum speed settings of the OS, and the speed setting in our technique. Our technique reduces selection time while maintaining about the same error rate compared to default speed, thereby illustrating the effectiveness of our proposed method.
One of the difficulties with standard route maps is displaying routing information in both large scale to show details and small scale to show an overview. We propose a new hierarchical structure for route maps called a “Route Tree” to address this problem, and describe an algorithm to automatically construct such a structure. A Route Tree is a structure that can be used by various applications, and in this paper we propose two Route Tree applications, interactive map browsing and route information printing. We run evaluation studies with two proposed applications and the study showed a promising results.
This study proposes tangible devices that assist non-expert users to design specific navigation routes for mobile robots. The user places the devices, called pebbles, on the floor along the paths to the places where the user wants the robot to move. With infrared communications, pebbles know their network topology by exchanging information about visible neighbors, and the robot then plans a navigation path and moves along the devices in the path. During the deployment, the system provides LED and voice feedback for the user to know if devices are appropriately connected without expert knowledge. In addition, because there is a device at each goal location, our method supports to name locations by associating a device ID with a particular name. Our user study showed that the system feedback largely worked to help non-expert users to design robot navigation. We also discuss observations and participants' comments of the user study.
Quantitative estimation of fault occurrence is mandatory in the evaluation of IT risks. Behavior of open systems is subject to dynamically changing external environment, which sometimes results in runtime interference of their functional features. The estimation at the development stage may differ from the occurrence rates of the actual system. This paper proposes to apply the notion of statistical model-checking to a runtime checking of running programs. It further demonstrates the usefulness of the proposed approach by conducting experiments in the case of a simple Web application system.
We propose a stakeholder analysis method focusing on the dynamic interests and their interactions arising from the behavior of the stakeholders. The proposed method allows to model stakeholder's roles, activities and interests associated with the activities, and to evaluate the dependencies of interests among them with a contribution/risk matrix. We applied the proposed method to the energy saving problem in our university, and demonstrated the effectiveness of the method.
Software model checkers such as Java PathFinder (JPF) can discover errors in software during the test phase. However, the state space explosion is a serious problem.Various heuristic search methods, which explore the state space based on given priority function, have been proposed to solve this problem. The efficiency of a heuristic search depends on target programs. Therefore, we need various methods and heuristic functions for applying the target programs. This paper proposes a heuristic search method based on space limited search. While the existing heuristic methods control the search order with given priority values for the states, the proposed method uses search cutoff policy. It cuts off the forward search beyond the state whose probability to reach error state is evaluated low. We enhanced the JPF search engine with the proposed method to evaluate our approach. We examined our method comparing to the existing heuristic methods with test programs written in Java which are designed to evaluate model checkers. Experimental results show that the performance of our method is more than twice as much as the existing heuristic search in many cases. Therefore, the proposed method enlarges the applications of heuristic search.
As traceability is a factor in software maintainability, various methods have been reported to preserve it. However, perception of traceability tends to be subjective because there is no indicator which represents the degree of it. We propose an approach to measure traceability between a design model described in UML and source code written in object-oriented language. In detail, our approach maps a design to its implementation with the semi-automatic original algorithm and measures traceability with the Goal-Question-Metric approach. We apply the approach to pairs of a design model and source code and find that the degree of traceability can be presumed with a little work even by a third person.
This paper proposes a context-oriented programming (COP) language EventCJ. COP is a programming technique that helps to modularize context-dependent behavior and contexts by using partial methods and layers, respectively. Changes of contexts in the specification are changes of the states (active or inactive) of layers in the COP program. EventCJ is designed on top of Java and provides layers as the means of modularizing behavior with respect to each context. It also provides event declarations and layer transition rules, which are not available in other COP languages. The two mechanisms enable us to separate changes of the states of each layer from other concerns and control the states of layers independently from calling contexts. This paper shows the language design of EventCJ through a simple example and gives a calculus called Featherweight EventCJ, which is an extension of ContextFJ, to show the semantics. Compilation is achieved by translating EventCJ programs to AspectJ. The paper also gives a simple idea to optimize EventCJ programs.
Since the confluence property of term rewrite systems is persistent, a term rewriting system R is confluent if it is decomposed into small subsystems by introducing appropriate many-sorted types and each of them is confluent. However, if introducing types does not decompose R into small subsystems, this proof method does not work. In this paper we propose a new method for confluence proof based on persistency, which can be applied to non-left-linear term rewriting systems not decomposed into subsystems by introducing types.
An abstract numeration system (ANS) is a numeration system that provides a one-to-one correspondence between the natural numbers and a regular language. In this paper, we define an ANS-based compression as an extension of this correspondence. In addition, we show the following results: (1) an average compression ratio is computable from a language, (2) an ANS-based compression runs in sublinear time with respect to the length of the input string, and (3) an ANS-based compression can be extended to block-based compression using a factorial language.
Distributed SPARQL query processing is considered as a desirable solution to improve the query performance for large RDF graphs. Most previous works are based on data or query decomposition, which often results in poor scalability due to communication overheads between servers. We propose a new approach to distributed SPARQL processing based on range partitioning which needs just a single communication cycle. Preliminary experimental results for LUBM show almost linear speedups for most queries.
Design by Contract (DbC) is one of key concepts of software development. According to the concept, designers explicitly define each class or method specification as assertion to be satisfied. It has the following advantages. First, it helps to understand the software specification and to verify the program. Secondly, sufficient description of assertion for a method helps users understand behavior of the method without the details of the implementation. Finally, it enhances information hiding and modularity. Defect that description of assertions is insufficient or inconsistency between specification and implementation, however, sometimes counteracts these advantages. This study proposes a method to detect and to help users find defects of specifications described by JML (Java Modeling Language). Our method utilizes Alloy Analyzer. An application experiment has been performed on a ware-house management program, which is the famous common problem for software development. As a result, eight defects of the assertion were detected. We can thus sure the effectiveness of this method was confirmed.