The debugging support for beginner programmers has been an active research area in recent years. However, instead of directly supporting their debugging, training such programmers to be intermediate programmers by using exercises to debug programs is overlooked. In this training, it is important to prepare the programs including bugs that capture the tendency of beginner programmers. Therefore, we focused on Learning-Mutation, which learns the bugs using machine translation from buggy programs and fixed programs, and automatically induces bugs into programs. In this study, we applied Learning-Mutation to the programs written by beginner programmers at Kyushu University. By comparing the induced bugs by Learning-Mutation with the actual bugs by such programmers, we evaluated whether Learning-Mutation can be used to support the exercises by preparing the programs including bugs. As a result, the induced bugs are similar to the actual bugs, and the patterns of bugs that are forgetting semicolons and undeclaring variables or functions accounted for more than 36% when the number of tokens was small. On the other hand, as the number of tokens increased, the number of incorrect expressions increased. Furthermore, although there are bugs that are difficult to generate, beam search relieves this difficulty.

The name of a method is an essential clue to comprehending what the method does. An inconsistency between the method's behavior and its name—especially its first word—is referred to as a “naming bug,” leading to deterioration in the code readability. This paper proposes applying a Transformer-based machine learning model to detect naming bugs in Java methods. The proposed model can evaluate a method name's consistency by suggesting a proper name from the method's body. The empirical study proves the proposed model outperforms the conventional model using Doc2Vec, Word2Vec, and convolutional neural network.

On software development, productivity (defined by dividing software size by development effort) relates to the development cost, and therefore, it is very important for stakeholders. Many studies have tried to clarify factors affecting productivity of software development, focusing on main programing language (i.e., usage ratio of the language is the highest). However, there is no study which focuses on the usage ratio of each language, as far as we know. To enhance the accuracy of productivity analysis, we analyzed productivity factors, considering the usage ratio of programming languages. We analyzed 450 software projects collected from cross companies, and the result suggests that development effort is decreased by 33%, when the usage ratio of MS-ACCESS is 100%.

Open Source Software (OSS) Development Projects are always looking for contributions from new developers to maintain the sustainability of the project. Some projects use a label called “Good First Issue (GFI)” to support onboarding by preparing issues for new developers. However, GFI labels are not initiatively used in many projects because labeling is done manually by project maintainers, which is burdensome for maintainers. The aim of this research is to construct a machine learning model to automatically classify issues for new developers in OSS projects. In this paper we describe the results of constructing a classification model using random forests method. We collected about 150,000 regular issues and about 10,000 GFIs, and conducted a 10-fold cross validation, resulting in a Precision of 0.91 and a Recall of 0.30 (RQ1). We also analyzed the feature value with high importance and found that the role of the contributor in a project is important for the classification of GFIs (RQ2).

We propose a method to automatically correct erroneous control statements written in C, PHP, JavaScript, Python, and Ruby, in case statements are written according to the grammar of another language or mixed grammar of multiple languages. Such kinds of errors are likely to be made when a programmer learns multiple programming languages. In order to support the correction of such errors, we propose a method to analyze a grammatical erroneous code fragment with expression level syntax analysis, and to convert the code through a common model of control statements.

The concept of the test smell represents potential problems with the readability and maintainability of the test code. Common test smells focus on static aspects of the source code, such as code length and complexity. These are easy to detect and do not cause problems in terms of test execution. On the other hand, dynamic smells, which are based on test runtime behavior, lead to misunderstanding of the test results. For example, they give developers the false impression that the test was passed without any problems, even though the test was poorly executed. Therefore, we should detect dynamic smells and take countermeasures as early as possible through the development. In this paper, we propose JTDog, a Gradle plugin for detecting dynamic smells. JTDog has high portability due to its integration into the build tool. We applied JTDog to 205 projects on GitHub and confirmed that the JTDog plugin has high portability. In addition, JTDog detected 1,117 dynamic smells in 66 projects.

We have developed a visual programming tool called SmrAI for function testing, and investigated whether wrapping existing source code with Scratch Blocks is an effective means of mitigating the shortage of programming personnel in the manufacturing. SmrAI is based on Smalruby, which can convert Scratch Blocks into Ruby code. In addition, SmrAI introduces two new sets of Blocks that wrap existing Ruby libraries for function testing. Since existing tools and libraries were utilized, the cost of developing SmrAI was low, and there were no changes in the function testing procedure. We conducted a verification test using staff members who were familiar with the function testing process but had little or no programming experience, and confirmed that they were able to program using SmrAI and that they had confidence in its business applications. These results are expected to contribute to the diversification and increase of programming personnel responsible for function test programming.

Background: Tracking program elements in source code is useful for program comprehension, supporting code edit, and so on. Historage, a history tracking approach based on repository transformation, enables developers to use a familiar interface to track a finer-grained history. Problem: Existing repository transformation tools have performance issues: (1) their transformation steps include the expansion and archiving of snapshots from the object database, and (2) they cannot transform repositories incrementally, which are unsuitable when using them for supporting software development activities. Method: In this paper, we describe the design and implementation of a transformation tool, Tool, that reduces the transformation time. We use git-stein, a repository transformation framework based on the recording of the mapping between objects, to suppress unnecessary expansion and archiving of files. In addition, we store the mapping and use it later to support incremental transformation. Preliminary Evaluation: We compared the transformation time of our tool with an existing one. Furthermore, we compared performance when using different kinds of mappings to be stored. As a result, we found that our tool is more than four times faster than the existing tool and that storing object mapping is effective.

This paper presents a novel tool called UCDetector, which detects strong retain cycles and memory leaks that occur due to the limitation of Swift ARC mechanism. We provide a simple and compact implementation of UCDetector by utilizing the facts that Swift is statically-typed and thus safe, but it also allows low-level programming, as well as Swift reflection API and a debugger lldb’s Python API. We also present several findings that there are non-trivial obstacles in the implementation. Finally, we present a result of our preliminary evaluation on the accuracy and efficiency of cycle/leak detections, which show a promising result.

It is reported that the results of the code clone detection are drastically affected by clone detection tool and/or their detection parameters. However, it is not easy to set up execution environments for clone detection tools with different parameters and to compare the execution results. In this study, we have developed a SaaS-based code clone analysis environment, named CCX. By using CCX, developers can use currently five detection tools without installing them individually, and can easily compare and analyze their detection results.

We propose an automatic memory movie editing system using dashcam video data to summarize road trips and enjoy looking back at the road trip memories. While it is easy to obtain the high-resolution video data recorded by dashcams using Secure Digital memory cards, this data is rarely used except for safety purposes because it takes substantial time and effort to review or edit many hours of such recorded videos. The proposal system summarizes the video by selecting the important scenes in a trip, such as famous places and the excitement of conversation, and adds text messages, maps, and synthetic voices. In this paper, we describe the design of an automatic editing system implemented on the Web, the results of comparisons between manual and automatic editing, and the results of the user questionnaire. This research contributes to improving the driving experience by providing entertainment for automobile users after road trips.