Resource-constrained environments, such as embedded devices, have limited amounts of memory and storage. Practical programming languages such as C++ and Rust tend to output multiple similar functions by monomorphizing polymorphic functions. An optimization technique called Function Merging, which merges similar functions into a single function, has been studied. However, in the state-of-the-art approach, the number of functions that can be merged at once is limited to two; thus, efficiently merging three or more functions, which are often generated from polymorphic functions, has been impossible. In this study, we propose Multiple Function Merging optimization, which targets merging three or more similar functions into a single function using a multiple sequence alignment algorithm. With multiple aligned information, Multiple Function Merging can increase merge opportunities and reduce extra branching overheads at the code generation stage. We evaluated it using the SPEC CPU benchmark suite and some large-scale C/C++ programs, and the results show that it reduces code size by as much as 7.61% compared with the state-of-the-art approach.

Sustained input of lifelog data is critical for conversational health applications, where algorithms and AI advise users based on recorded lifelog data such as meals, exercise, and sleep. However, an effective method for presenting information to encourage this continuity has not been identified. This study developed three intervention methods for prompting lifelog entries: (a) wording adjustment based on individual characteristics, (b) timing adjustment based on physical activity, and (c) a combination of these adjustments. An empirical experiment with 422 participants was conducted to evaluate the effects.

Teachers often utilize automatic program repair methods to provide feedback on submitted student code using model answer code. A state-of-the-art tool is Refactory, which achieves a high repair success rate and small patch size (less code repair) by refactoring code to expand the variety of correct code samples that can be referenced. However, Refactory has two major limitations. First, it cannot fix code with syntax errors. Second, it has difficulty fixing code when there are few correct submissions. Herein we propose a new method that combines Refactory and OpenAI's GPT models to address these issues and conduct a performance measurement experiment. The experiment uses a dataset consisting of 5 programming assignment problems and almost 1,800 real-life incorrect Python program submissions from 361 students for an introductory programming course at a large public university. The proposed method improves the repair success rate by 1-21% when the set of correct code samples is sufficient and the patch size is smaller than Refactory alone in 16-45% of the cases. When there was no set of correct code samples at all (only the model answer code was used as a reference for repair), method improves the repair success rate by 1-43% and the patch size is smaller than Refactory alone in 42-68% of the cases.

To guide practitioners and researchers to design and research Machine Learning (ML) system development processes, we conduct a preliminary literature review on ML system development practices. We identified seven papers and two other papers determined in an ad-hoc review. Our findings include emphasized phases in ML system developments, frequently described ML-specific practices, and tailored traditional practices.

Background: Traditional programming education focuses on training students' ability to write correct code that meets the specifications in programming assignments. In addition to correctness, software engineering studies argue that code quality is important. Problem: Nurturing students' ability to write high-quality code in programming assignments is difficult due to two main reasons. (1) Considering code quality while grading is undesirable because there are no objective and fair measurement metrics. (2) Grading assignments from multiple viewpoints (correctness and quality) is difficult and time-consuming. Approach: We propose applying gamification with code metrics to measure code quality in programming assignments. Our approach can motivate students to write code with good metric scores independent of grading. We implemented our approach and conducted a control experiment in a programming course at a university. Result: Our approach did not interfere with students' submissions but improved metric scores significantly. Hence, our approach can engage students to write high-quality code.

Many researchers have proposed program visualization tools for memory management because this is a challenging concept for novice programmers. For example, SeeC and PythonTutor (PT) are state-of-the-art tools for C languages. However, three problems hinder the use of these and other tools: capability (P1), installability (P2), and usability (P3). (P1) Tools do not fully support dynamic memory allocation or File Input / Output (I/O) and Standard Input. (P2) Novice programmers often have difficulty installing SeeC due to its dependence on Clang and setting up an offline environment that uses PT. (P3) Revisualization of the modified source code in SeeC requires several steps. To alleviate these issues, we propose a new visualization tool called PlayVisualizerC (PVC). PVC, which is designed for novice C language programmers to provide solutions (S1-3) for P1-3. S1 offers complete support for dynamic memory allocation, standard I/O, and file I/O. S2 involves installation in a user web browser and its server program is initiated by executing a jar file. S3 reduces the steps required for revisualization. To evaluate PVC, we conducted an experiment and questionnaire involving 30 students. Students using PVC solved a set of four programming tasks on average 1.7 times faster and with 19% more correct answers than those using a current state-of-the-art visualization tool.

The concept of memory management in C programming language is particularly challenging for novice programmers. Consequently, many researchers have proposed program visualization tools to alleviate these difficulties: for example, SeeC is one of the state-of-the-art tools for visualizing the behavior and execution status of C programs. However, three problems (P1-3) remain in SeeC, as well as in other existing visualization tools. P1 (Usability): SeeC requires many steps to revisualize modified source code. P2 (Capability): SeeC does not fully support dynamic memory allocation. P3 (Installability): novice programmers often find installation of SeeC challenging due to its dependency on Clang. We propose a new visualization tool named PlayVisualizerC (PVC) for novice C programmers, which provides three solutions (S1-3) for P1-3. S1: PVC reduces the steps required for revisualization. S2: complete support for dynamic memory allocation. S3: designed to be installed in the user's web browser. From a small-scale experiment and a questionnaire given to 20 students, we found that a set of four programming tasks were solved 1.8 times faster and 24% more correctly using PVC.

Mutation analysis is a method for evaluating the effectiveness of a test suite by seeding faults artificially and measuring the fraction of seeded faults detected by the test suite. The major limitation of mutation analysis is its lengthy execution time because it involves generating, compiling and running large numbers of mutated programs, called mutants. Our tool MuVM achieves a significant runtime improvement by performing higher order mutation analysis using four techniques, meta mutation, mutation on virtual machine, higher order split-stream execution, and online adaptation technique. In order to obtain the same behavior as mutating the source code directly, meta mutation preserves the mutation location information which may potentially be lost during bit code compilation and optimization. Mutation on a virtual machine reduces the compilation and testing cost by compiling a program once and invoking a process once. Higher order split-stream execution also reduces the testing cost by executing common parts of the mutants together and splitting the execution at a seeded fault. Online adaptation technique reduces the number of generated mutants by omitting infeasible mutants. Our comparative experiments indicate that our tool is significantly superior to an existing tool, an existing technique (mutation schema generation), and no-split-stream execution in higher order mutation.

Feedback-directed random test generation is a widely used technique to generate random method sequences. It leverages feedback to guide generation. However, the validity of feedback guidance has not been challenged yet. In this paper, we investigate the characteristics of feedback-directed random test generation and propose a method that exploits the obtained knowledge that excessive feedback limits the diversity of tests. First, we show that the feedback loop of feedback-directed generation algorithm is a positive feedback loop and amplifies the bias that emerges in the candidate value pool. This over-directs the generation and limits the diversity of generated tests. Thus, limiting the amount of feedback can improve diversity and effectiveness of generated tests. Second, we propose a method named feedback-controlled random test generation, which aggressively controls the feedback in order to promote diversity of generated tests. Experiments on eight different, real-world application libraries indicate that our method increases branch coverage by 78% to 204% over the original feedback-directed algorithm on large-scale utility libraries.

Many program tasks require continuous modification of similar program elements, which is burdensome on programmers because continuous modifications are time consuming and some modifications are easily overlooked. To resolve this issue, we developed a tool, named Similar Highlight, which extracted all possible matching elements via similarity patterns from recently modified elements using a sub syntax tree comparison. Similar Highlight suggests similar program elements that may be modified during the next modification. Potential elements are highlighted and their text can be immediately selected by shortcut keys. Evaluations indicate that Similar Highlight can improve programming productivity. Currently, Similar Highlight supports C, C#, JAVA, Java Script, and PHP, but in the future we will expand it to other languages.

After a legacy system is re-engineered, it is important to perform compatibility testing so as to identify the differences and reduce the introduced bugs. We can first apply symbolic execution to obtain an exhaustive set of test cases, then use them to check the compatibility of the old system and the new one. However there may be a lot of failed test cases which are a mix of erroneous and allowable incompatibilities. To locate the causes of failures detected during the testing, we apply multiple statistical bug localization techniques. We are able to localize 90% of the incompatibilities in 10% of the code for an industrial application with around 20k lines by Tarantula. And we identify the characteristics of failure causes which are difficult to be detected by statistical bug localization.

Method names are important for the software development process. It has been shown by some studies that the quality of method names affects software comprehension. In response, some approaches that evaluate comprehensibility of method names have been proposed. However, the effectiveness of existing approaches is limited because they focus on part of names.

Computational thinking is one of the most important skills for using computers. Most existing learning systems for computational thinking work only on desktop or laptop computers, although the popularity of smartphones has rapidly been growing. Moreover, most existing programming languages to teach are based on English and most learning systems employ poor user interfaces. Thus, such programming languages and learning systems are not suitable for users who are not familiar with English or who are enchanted to such user interfaces. We propose a gamified learning system using an appealing user interface with a novel icon-based non-verbal programming language. Our system works on smartphones with which many Japanese teenager students are more familiar than PCs. Our system employs an appealing interface that a female student designs for other female students and icons to motivate university students to learn programming through playing. We conducted an experiment with 16 female students from Waseda University to evaluate our system. We confirmed our system motivated the students to learn programming and helped learn computational thinking concepts.

Although many programming languages and test coverage criteria currently exist, most coverage measurement tools only support select programming languages and coverage criteria. Consequently, multiple measurement tools must be combined to measure coverage for software which uses multiple programming languages such as web applications. However, such combination leads to inconsistent and inaccurate measurement results. In this paper, we describe a consistent and flexible framework for measuring coverage supporting multiple programming languages, called Open Code Coverage Framework (OCCF). OCCF allows users to add new extensions for supporting programming languages and coverage criteria with low development costs. To evaluate the effectiveness of OCCF, sample implementation to support statement coverage and decision coverage for eight programming languages (C, C++, C#, Java, JavaScript, Python, Ruby and Lua) are demonstrated. Additionally, applications of OCCF for localizing faults and minimizing tests are shown.

UML class diagrams representing the static structure of the relations between different concepts existing in a problem are widely used in model-based software development. However, no effective measures of a class diagram's understandability yet exist. We have devised quantitative measures of a class diagram's understandability and evaluated their validity. We obtained strong correlations between the domain experts' subjective evaluations of the understandability of a class diagram and the measurements of our methods. These results indicate that our measures can effectively quantify the understandability of class diagrams.