This paper presents our practice of an open lecture for introducing mathematical reasoning, for from 5th to 8th-grade students, with an educational goal of giving opportunities to find the implicit truths hidden within documents. For making a lecture suitable for students mentioned above, we have arranged from our experience about formal method, B-Method, that experience is an original of our college. As the result, we got certain evaluations from the students. Therefore, we have achieved our educational goal mentioned above.
Robotic process automation (RPA) is a technique mainly aimed at automating desktop tasks by creating bots that mimic human behavior. In the RPA, code smells causing defects are considered to have different characteristics from those of conventional programs. Therefore, this study defines a taxonomy for RPA based on code reviews and classifies the code smells. The result of this classification demonstrates the importance of using existing commands provided by RPA tools as much as possible to prevent defects from being introduced. In addition, it was observed that the setting of the waiting time of the process is also important for RPA bots. A preliminary defect detection tool that uses code reviews and code similarities was also developed. As a result of an evaluation, it was concluded that the regularity of the code generated by the RPA would result in high accuracy.
Errors in program comprehension are surprisingly difficult to be recognized, even by the developers themselves. In order to avoid overlooking errors during understanding, it might be useful to provide developers with their own comprehension-status estimated objectively. Previous studies estimated the comprehension-status on a per-function basis by analyzing a program and heartbeat during viewing it. However, this method cannot estimate the comprehension-status for a part of a function because the number of data points for analysis become fewer. In this study, we proposed the analysis method for estimating the comprehension-status on a part of a function by calculating program-characteristics and psychological-characteristics. Program-characteristics are defined by variable coupling between a part of a function and whole function. Psychological-characteristics are defined by weighted heart metrics with the degree of attention obtained from eye gaze. Through program-comprehension experiment, it was confirmed that the proposed method can estimate the comprehension-status. Thus, the estimation of the correctness of comprehension is expected to be applicable especially for inexperienced developers.
For automated program repairs (APR), the cost of the patch generation process will be reduced if automatically-generated test suites can be used. Automatic test-case generation techniques often take classes as input. This study aims at identifying which classes should be given as input for the aforementioned technique. In this study, we investigate the relationship between the test suites that detected failures and the actual classes that had bugs ﬁxed by developers. We observe the cases where test suites do not identify the classes fixed by developers as a cause of failures. We also find that these cases occur when the classes fixed by developers are on the traces generated by test suites' exercises. Based on this finding, we examine the impact of the automatically generated test-suites on the performance of APR. We demonstrate, taking into account all the classes exercised by the failed test cases, that the total number of generated patches decreases but the number of correct patches increases.
There are many coding standards (coding rules) which developers should comply with. However, this not always the case. In this paper, we report the results of investigating coding standard violations and their resolutions through means such as refactoring. The target of our study was the repositories of 1,000 OSS projects. We applied 87 coding standards that were implemented within Cpplint, which is a tool that checks for coding standard violations in programs written in the C++ language. The results showed that there are two types of rules: (1) rules that developers always comply with in a “common sense” way; (2) rules that developers are not conscious of and as a result does not comply with. In the first type of rules, violations did not occur very often, and even when they did, there was a strong tendency for them to be corrected. In the second type of rules, violations did occur often, and when they did, there was a strong tendency for them not to be corrected. We also investigated if such tendencies changed during the development process. We found that for certain rules which are automatically corrected by IDEs, there were significantly more projects where the tendency for compliance changes compared to other rules. This suggests that for rules where developers do not have a conscious understanding of complying, the auto-correct function of IDEs causes the compliance regardless of the developer's intent.
An operation history which was recorded in source code editing enables us to understand past source code changes more precisely. However, since it is laborious to investigate each edit operation in such a history, more efficient method for understanding a program change history is required. To generate a change history which is more abstract and easy-to-understand, we previously proposed an operation history graph called OHG, which is derived from recorded operation histories. In this paper, we propose FOHG, which is an extended version of OHG. FOHG can contain the entire abstract syntax trees (ASTs) which are obtained by parsing code snapshots after each edit operation, while OHG omits the code structure in methods. In this paper, we describe the structure of FOHG and a method for graph generation. Moreover, we explain the result of an experiment where we evaluated how precisely FOHG can represent past refactoring operations since understanding refactoring is considered significant in code change understanding. The result shows effectivity of our method for both automated and manual refactorings. Our method can detect more various refactorings than existing refactoring detection tools using operation histories. Understanding manual refactoring can also be supported by using edges which are generated when cut-and-paste operations and changing a part of a token are performed.
String constraints are logical formulas with regular expressions and string manipulating functions, and emerge in analysis of string manipulating programs. We develop a procedure to check satisfiability of syntactically-restricted string constraints with transducers. A streaming string transducer (SST) is a variant of a string-to-string transducer that computes an output with a fixed number of string variables. We also employ a Parikh automaton (PA), a string acceptor which computes a vector of natural numbers for an input and accepts if the vector satisfies a given arithmetic formula. We first show construction of the pre-image of a PA under an SST. Then we apply the result to show decidability of string constraints that may contain string replace functions using regular expressions with capture groups, and substring functions. The decision procedure is implemented as an SMT solver for string theory, and compared with existing solvers through an experiment on several constriants.