Consistency is one of the keys to maintainable source code and hence a successful software project. We propose a novel method of extracting the intent of programmers from source code of a large project (~ 300 kLOC) and checking the semantic consistency of its variable names. Our system learns a project-specific naming convention for variables based on its role solely from source code, and suggest alternatives when it violates its internal consistency. The system can also show the reasoning why a certain variable should be named in a specific way. The system does not rely on any external knowledge. We applied our method to 12 open-source projects and evaluated its results with human reviewers. Our system proposed alternative variable names for 416 out of 1080 (39%) instances that are considered better than ones originally used by the developers. Based on the results, we created patches to correct the inconsistent names and sent them to its developers. Three open-source projects adopted it.

We investigated how programmers express high-level concepts such as path names and coordinates using primitive data types. While relying too much on primitive data types is sometimes criticized as a bad smell, it is still a common practice among programmers. We propose a novel way to accurately identify expressions for certain predefined concepts by examining API calls. We defined twelve conceptual types used in the Java Standard API. We then obtained expressions for each conceptual type from 26 open source projects. Based on the expressions obtained, we trained a decision tree-based classifier. It achieved 83 % F -score for correctly predicting the conceptual type for a given expression. Our result indicates that it is possible to infer a conceptual type from a source code reasonably well once enough examples are given. The obtained classifier can be used for potential bug detection, test case generation and documentation.

Head-Mounted Displays, or HMDs, are rapidly spreading in recent years. However, existing text input methods for HMDs have several problems, hampering their further popularization. In this paper, we focus on the two problems with existing text input methods: (1)the difficulty of its setup and (2) the space needed for its operation. To address these problems, we propose a novel text input system for HMDs. Our system (1) builds on top of a commodity camera device, Leap Motion, and (2) enables effective input in a small physical/virtual space, with a virtual 12-key keyboard. Our experimental results show the advantage of our approach over existing hand-tracking text input systems; especially our method indicates the effectiveness for Japanese text input, with a small virtual keyboard. Based on the experimental results, we believe that our text-input system is effective for any language in HMD environments, if we have a 12-key keyboard tuned for each language (as well as Japanese).

We are trying to find source code comments that help programmers understand a nontrivial part of source code. One of such examples would be explaining to assign a zero as a way to "clear" a buffer. Such comments are invaluable to programmers and identifying them correctly would be of great help. Toward this goal, we developed a method to discover explanatory code comments in a source code. We first propose 12 distinct categories of code comments. We then developed a decision-tree based classifier that can identify explanatory comments with 60% precision and 80% recall. We analyzed 2,000 GitHub projects that are written in two languages: Java and Python. This task is novel in that it focuses on a microscopic comment ("local comment") within a method or function, in contrast to the prior efforts that focused on API- or method-level comments. We also investigated how different category of comments is used in different projects. Our key finding is that there are two dominant types of comments: preconditional and postconditional. Our findings also suggest that many English code comments have a certain grammatical structure that are consistent across different projects.

Multithreaded programs are prone to dataraces. Dataraces are known to be hard to detect and reproduce by manual effort, although they often have detrimental effects on program reliability. Automated techniques are thus demanded for detecting dataraces efficiently and precisely. There have been proposed a lot of datarace detectors so far, among which dynamic ones are promising because of their precision. However, existing dynamic race detectors incur high race-checking overheads. Even a state-of-the-art dynamic race detector, called Parallel FastTrack, fails to efficiently detect races under certain conditions, despite its attempt to parallelize race detection for efficiency. In this paper, we propose an efficient and precise parallel race detector. For our proposal, we first experimentally reveal that the load-distribution policy of Parallel FastTrack tends to skew race-checking loads to a few detection threads. We then present a simple but effective technique, called POI, for balancing race-checking loads among detection threads. POI takes race-checking loads of each detection thread into account and reduces the load skew by making each detection thread manage almost the same number of memory addresses to be checked. Experiments on several real multithreaded data-processing applications show that POI succeeded in reducing, on average, about 37% of race detection overheads, which the load-distribution policy of Parallel FastTrack would impose.

For better programming language education, it is crucial to make compiler warning messages more understandable for novice programmers. Unfortunately, however, Kojima’s research showed warning messages in commercial-level compilers like GCC are still difficult to understand, and the commercial-level compilers tend not to emit how to modify programs to correct the problems. Furthermore, we found that they also tend not to handle latent errors. To solve this problem, by using a heuristic approach, we propose a novel C static checker called C-Helper, that aims to emit more direct error messages understandable for novices to correct wrong programs, and also aims to handle latent errors. Our preliminary evaluation shows that C-Helper was positively evaluated, although our heuristic approach increased false-positives.

This paper proposes a novel visualization tool for educational compilers, called MieruCompiler. Educational compilers that generate native assembly code like i386 have many practical and pedagogical advantages, but they also have a disadvantage that the undergraduate students need to acquire a wide range of knowledge on native machine instructions, assembly directives, application binary interface (ABI), so on. To reduce this learning cost, MieruCompiler provides various visualizations as a rich internet application (RIA) including: (1) highlighting all related slices (called "horizontal slicing" after [13], but not implemented in [13]) among the source code, abstract syntax tree, assembly code, symbol table, stack layout and compiler code, when the user hovers the mouse pointer over a piece of them, (2) displaying tooltips for machine instructions, assembly directives, etc., and (3) visualizing stack layouts which are very likely to be implicit. As a preliminary evaluation, MieruCompiler was used in two universities, which produced promising results.

In this paper, we propose a debugging technique for C, which can dynamically find boundary errors on strings in a highly-compatible, accurate and efficient manner. The main idea of our technique is to effectively keep track of hazardous memory bounds (called trap regions) using a small table (called a trap cache) on the static section of the instrumented program. We have implemented our technique as an extension of GCC4.1.1 and conducted experiments. The results show that our technique was easily applicable even to large real programs including Apache 1.3.37 and Linux 2.6.20.4 without requiring significant manual effort, it successfully detected all of ten known boundary errors in them with no false positives, and it incurred low run-time overheads (average 17%) for their benchmarks.

Data races can occur even in sequential programs due to asynchronous software interrupts (e.g., UNIX signals). In this paper, we propose and implement a new tool DRACULA that dynamically detects data races caused by UNIX signals. DRACULA has many positive characteristics like full-automation, no source code required, high scalability, and synchronization mechanism independence, which make DRACULA highly practical. Our preliminary evaluation of applying DRACULA on SPARC and IA32 platforms to Bash-3.0, consisting of around 89 KLOC in C code, produced promising results; the rates of false-positives are very low (2.6% and 7.0%) and DRACULA automatically reported 3 actual data races in Bash-3.0.

C preprocessor (CPP) is a major cause that makes it much difficult to accurately analyze C source code, which is indispensable to refactoring tools for C programs. To accurately analyze C source code, we need to generate CPP mapping information between unpreprocessed C sourcecode and preprocessed one. Previous works generate CPP mapping information by extending the existing CPP, which results in low portability and low maintainability due to the strong dependency of CPP implementation. To solve this problem, this paper proposes a novel approach (called TBCppA) based on tracer, which generates CPP mapping information by instrumenting the unpreprocessed C source code using XML-like tags called "tracers". The advantage of TBCppA is high portability and high maintainability, which the previous methods do not have. We successfully implemented a first prototype of TBCppA, and our preliminary evaluation of applying TBCppA to gcc-4.1.1 produced promising results.

In this paper, we present a novel method to detect virtual functions in C+ + programs using a light-weight binary-level analysis. We developed a tool, dcgg, that statically generates call graphs for C++ using DWARF2 debugging information based on this method. We use a combination of a binary analysis and debugging information to detect static function calls (including inline expanded functions) simply and precisely, and also virtual function calls (dynamic function calls in C++). Virtual function calls are detected by tracing types in registers and the stack. In a preliminary evaluation dcgg generated precise call graphs including inline expansions and virtual function calls. These techniques are important to C++ programmers as they help in creating efficient and maintainable code.

In embedded software development, the programming language C and inline assembly code are traditionally widely used. However, tools for C program-understanding, e.g., cross-referencers or call graph extractors, are not mature still today. In this paper, we introduce a novel technique for developing program-understanding tools, based on binary-level lightweight data integration. To verify this idea, we first propose a new markup language for DWARF2 debugging information, and then, using the technique, we experimentally developed two cross-referencers (called dxref and rxref) and a call graph extractor (called bscg) for C. Our preliminary evaluation shows that the technique enabled us to efficiently develop practical and flexible tools.

We propose an environment for evolutionary prototyping technique, which is a theoretical framework based on abstract interpretation for Java programs. In general, it is difficult to execute a prototype in the intermediate stage of top-down development. This disadvantage prevents us to find bugs in the early stage of the development. The technique we propose here allows programmers to execute the prototype as a whole, even though it is partially implemented. In the technique, an object is repeatedly changed with interface changes. Our idea is to use an earlier runnable object instead of an unimplemented later object in runtime. The changes of objects are based on abstract interpretation. However, it is necessary to realize the mechanism for using the alternative object including the interface changes in Java. To solve this problem, we introduce proxy object, which is a mediator containing all interface and transform objects dynamically and automatically to keep execution going. Moreover, proxy objects can be automatically generated by the dynamic proxy class API, which is one of Java reflection mechanism. As a result, our environment would reduce the cost that programmers describe code for adjusting current objects.

The aim of this paper is to demonstrate the significance of XML semantics checker approach. We apply this novel approach to check the semantic consistencies of the Quran holy book that is mentioned by Jon Bosak in Religion 2.00 Web site. Religion 2.00 is a group of four religious works marked up for electronic publication from publicly available sources. In this paper, we will concentrate mainly on studying the case study of the Quran holy book that is mentioned in the previous web site. We successfully applied our approach of XML semantics to check that the number of verses in each chapter was correctly written in the Quran XML format document. We also checked that the Quran XML document contains exactly the same number of chapters as in the real Quran holy book. In addition, we computed automatically the total number of verses in the holy book.

We address the problem of checking the consistency of the semantics associated with an eXtensible Markup Language (XML) document. We propose a new technique to implement the incremental attribute evaluation approach to check the consistency of XML documents from the semantics point of view. In a previous paper, we have proposed a new technique to add semantics to XML documents by attaching the semantics information to the XML element tag attributes. This approach is based on the same concept as in attribute grammars (AGs) by attaching and checking static semantics of programming languages through their attributes. We extend our work by adding incremental facilities to the proposed evaluator. By introducing the incremental approach to our technique we improve its efficiency by minimizing the re-evaluation process. Only the affected areas in the XML document are re-evaluated rather than re-evaluating the whole document.