Architecture styles such as MVC and its derived ones have been proposed to support interactive systems development. Within these styles, they have tried to separate some valuable concerns which crosscut over the systems' dominant, namely object-oriented module decomposition. Interactive systems in recent days are required to behave differently according to their surrounding environment. They are equipped with the facilities for handling responsive Web design, mobile devices and so forth to deal with such requirements. In this paper we discuss design and practicality of an aspect-oriented software architecture named CSA/I-Sys (Common Software Architecture for Interactive Systems) as a basis for the architecture-centric interactive systems development. CSA/I-Sys is designed using a software pattern named PBR (Policy-Based Reconfiguration) which we have defined to represent self-adaptive mechanisms at the architectural level of abstraction. Since PBR pattern provides a simple mechanism which is commonly applicable to handle both crosscutting concerns and varying behaviors in designing interactive systems, CSA/I-Sys resulting from PBR pattern becomes a concrete infrastructure for reusing coarse-grained software assets such as library and middleware.

In this paper, we propose an approach for detecting block clones (i.e., block-level code clones) using information retrieval techniques. In the previous study, we have presented an approach for detecting function clones. However, the previous approach misses a number of code clones because it only identifies coarse-grained code clones (i.e., function clones). To mitigate this problem, this study proposes an approach that detects block clones by generating feature vectors for code blocks based on the occurrence of identifiers and reserved keywords and then performing clustering of the generated vectors. Also, we improve a clustering method and a data structure of feature vectors in the proposed approach. It leads not only the detection of fine-grained code clones but also less detection time and low memory consumption, compared to the previous approach.As a case study, we compared the proposed approach with the existing code clone approaches and then confirmed the effectiveness of the proposed approach.

It is important to manage risks in software development. To manage the risks, risks which may occur in the project are identified by some methods such as brainstorming, and risk treatment plans are made based on that. However, risk recognition is considered to include biases, and it may affect correctness of identification of the risks. To recognize the risks precisely, we clarified risk recognition of software developers. Our study identified the risk recognition quantitatively using the questionnaires based on Slovic's study. The answers of questionnaires are compressed to two factors (dread and unknown). We analyzed answer of questionnaires collected from 69 subjects (most of them are software developer). As a result, strength of “dread”and“unknown”factors were different among risks, when experience of risk was different among subjects, and the difference affected the recognition to severity of each risk.

The equivalence problem for functions is not decidable in general. However it is known that some syntax restrictions can make it decidable. The class of deterministic top-down tree-to-string transducers (yDT) is one of such syntax restricted transducers. yDT can express more functions than any other transducers for which the equivalence problem is decidable. The decidability of the equivalence problem for yDT was established in 2015 by Seidl et al. Seidl's proof consists of two semi-algorithms, so it is impossible to determine the computational complexity and if it is practical or not. In this paper, we assess the potency of their algorithm by its implementation and experiments.

Since 2000, SAT solvers that are programs solving SAT instances has enormously progressed in performance. Due to the performance improvement, SAT-based systems that encode problems into SAT instances and solve them by SAT solvers have succeeded in various research fields such as planning, software/hardware verification, scheduling problems, etc .In this paper, as recent advances in SAT solvers, we first explain the progress of their performance and functions from the viewpoint of the international competition of SAT solvers which is a factor of their progress. Then, from the viewpoint of utilization technologies, we explain that we can solve more complex problems by combining progressive functions of SAT solvers with encoding methods. As an example, we explain a solving method for the multiobjective optimization problems by using SAT solvers.

Toward improving readability of source code, this paper proposes a model for judging the compatibility between Java method's name and its implementation, and conducts empirical studies and a survey to examine its usefulness. The proposed method constructs decision trees with many method's data from various source programs, and judges the compatibility between method's name and its implementation. As the results, a validity of model is confirmed and the judging accuracy (F-measure) is about 80%. It is also confirmed that the judgment by the model approximately dovetails with developers' sense.

This paper presents a feasibility study to predict software bugs in statement level. The proposed method uses a window to inspect a given source file containing a bug. By moving the window from the top to the end of a source file, a set of buggy windows and non-buggy windows are derived. Then, we construct a spam filter-based bug prediction model, whose input is a set of tokens in a window and output is the probability of containing a bug in the window. Finally, we integrate bug prediction results on these windows to compute the probability of containing a bug in each statement. We conducted a feasibility study using 593 source files each containing one bug, and found that, by using the size=3 window, we could identify 67.1% of bugs in top 10 buggy statements of each source file prioritized by our bug prediction, which suggests that the bug pinpointing is feasible.

In programming education, we propose a prototype of program proofreader, which checks whether learners' programs match learning objectives. Learners sometimes tend to think that their tasks are accomplished when their programs produced the same outputs with ones of sample test cases. However, their programs sometimes are not well-written one, that is, they are unsuitable codes for exercises' objectives. To find poorly-written programs, we have implemented a program proofreader which compares learners' programs to a model program written by a teacher from views of learning objectives.

It is desirable for software companies to assess the quality of open source software (OSS) in order to avoid degradation of product quality due to the quality of OSS. In this study, we conduct a questionnaire survey to understand which quality are required by developers for OSS in each development type and assess the quality of OSS when considering the results of the questionnaire survey. We target the OSS systems used in the development projects of Fujitsu Kyushu Network Technologies Limited. When comparing the questionnaire result with each development type, with five questions, there is a difference of 20% or more in proportion that “Important” or “Somewhat important” is answered. We set the weight for each evaluation item based on the questionnaire for each development type, and as a result of evaluating 6 OSS systems, we find that our approach detects 7 items from 12 items that developers evaluated as risky.

In this paper, we investigate the possibility and effectiveness of the approach to generating bug-fixing patterns extracted from Stack Overflow, which is a question and answer web site for programming. To do so, we collect 984,533 posts with the Android tag in Stack Overflow and extract top 10,000 ones related to the tag. Results show that (1) there are 28 posts that would be able to generate bug-fixing patterns, (2) there are 42 posts that are useful to fix bugs, and (3) those 42 posts include bug fixing patterns that are not supported by a previous study (PAR: Pattern-based Automatic program Repair).

First-order unification algorithms on finite terms are formalized by inference rules, and their termination, soundness and completeness have been presented in many papers. Unification algorithms on rational terms have also been presented in several papers. However, it has not been shown that the solution of the set obtained by inference rules from a given set of equations coincides with the rational substitution which is the most general unifier of the original set. Furthermore, the precise proofs of termination, soundness and completeness are not clear in many cases. In this paper, we revisit the foundations of unification algorithm on rational terms within the framework of term rewriting systems. First, we show that the solution of a regular system is the most general unifier of the set of equations corresponding to the regular system. Next, we reformulate the unification algorithm on rational terms by inference rules, and then give the proofs of its termination, soundness and completeness, respectively. Finally, we show that a unifiable set of equations has a most general unifier as a rational substitution.

Each commit in repositories of version control systems should include code changes for only a single task. However, in real repositories, there are many commits for multiple tasks and tasks split into multiple commits. We call the latter IP commits (inappropriately partitioned commits). In this research, we firstly investigate how many and what kinds of IP commits are included in repositories. Then, we classify the found IP commits into three categories. Based on the classification, we propose a new technique to detect IP commits automatically. This is the first research that proposes a technique to detect IP commits. To evaluate the proposed technique, we applied it to repositories of two open source software. The results showed that the proposed technique detected IP commits with high accuracy (precision is 0.8 and F-measure is 0.7).