Code Review Automation can reduce human efforts during code review by automatically providing valuable information to reviewers. Nevertheless, it is a challenge to automate the process for large-scale companies, such as Samsung Electronics, due to their complexity: various development environments, frequent review requests, huge size of software, and diverse process among the teams.

Static code analysis in Continuous Integration (CI) environment can significantly improve the quality of a software system because it enables early detection of defects without any test executions or user interactions. However, being a conservative over-approximation of system behaviours, static analysis also produces a large number of false positive alarms, identification of which takes up valuable developer time. We present an automated classifier based on Convolutional Neural Networks (CNNs). We hypothesise that many false positive alarms can be classified by identifying specific lexical patterns in the parts of the code that raised the alarm: human engineers adopt a similar tactic. We train a CNN based classifier to learn and detect these lexical patterns, using a total of about 10K historical static analysis alarms generated by six static analysis checkers for over 27 million LOC, and their labels assigned by actual developers. The results of our empirical evaluation suggest that our classifier can be highly effective for identifying false positive alarms, with the average precision across all six checkers of 79.72%.

Defects are common in software systems and cause many problems for software users. Different methods have been developed to make early prediction about the most likely defective modules in large codebases. Most focus on designing features (e.g. complexity metrics) that correlate with potentially defective code. Those approaches however do not sufficiently capture the syntax and multiple levels of semantics of source code, a potentially important capability for building accurate prediction models. In this paper, we report on our experience of deploying a new deep learning tree-based defect prediction model in practice. This model is built upon the tree-structured Long Short Term Memory network which directly matches with the Abstract Syntax Tree representation of source code. We discuss a number of lessons learned from developing the model and evaluating it on two datasets, one from open source projects contributed by our industry partner Samsung and the other from the public PROMISE repository.

Recently, concolic testing has drawn a lot of attention from the research community as a practical solution of overcoming limitations of manual test case generation. CONBOL, a concolic testing framework for large-scale embedded industrial software, has shown effectiveness of discovering real defects even for commercial quality software. In this paper, we extend CONBOL to be applicable to a project written in C++. Front-end of CONBOL is re-implemented based on LLVM and concolic engine is also modified. We design an enhanced DFS search strategy to enlarge search space when there an infinite loop exists in the execution path or control flow is too complex to be traversed. After applying to real world project, we prove that enhanced search strategy is better to increase test coverage. Finally, we investigate reasons of segmentation faults during concolic execution and suggest several heuristics to decrease segmentation faults.

Current testing practice in industry is often ineffective and slow to detect bugs, since most projects utilize manually generated test cases. Concolic testing alleviates this problem by automatically generating test cases that achieve high coverage. However, specialized execution platforms and resource constraints of embedded software hinder application of concolic testing to embedded software. To overcome these limitations, we have developed CONcrete and symBOLic (CONBOL) testing framework to unit test large size industrial embedded software automatically. To address the aforementioned limitations, CONBOL tests target units on a host PC platform by generating symbolic unit testing drivers/stubs automatically and applying heuristics to reduce false alarms caused by the imprecise drivers/stubs. We have applied CONBOL to four million lines long industrial embedded software and detected 24 new crash bugs. Furthermore, the development team of the target software adopted CONBOL to their development process to apply CONBOL to the revised target software regularly.

As a program written in multi-staged language can generate and execute code fragments in execution time, it is hard to predict how many code fragments will be generated in execution time. Therefore, current test coverages are not likely to give right answers when they are apply to a program written in multi-staged language because the program size could not be estimated easily. In this paper, we present static analysis which detects code fragments generated in execution time using abstract interpretation and prove the correctness of analyzer. Moreover we propose new test coverage for multi-staged language using the result of analysis.

Test driven development uses unit tests for driving the design of the code. Mock object is an object that imitates the behavior of an object with which class under test has an association to assist the unit testing. Although many tools for mock object are used in practice, there has been few research on defining the mock object model. For the comparisons of the testing capability of the tools, it is important to define the models. In this paper we represent the models of the existing mock object tools and indicate the limitations of them. In addition we propose a new model to overcome the limitations of the existing tools. With this model, more general behavior of the class under test related to the mock object can be expressed and tested.

Distributed systems, such as grid, are operated on many heterogeneous platforms. In such grid environments, each subsystem tends to be developed under different programming languages including non object-oriented languages. Nowadays, UML is the de-facto standard for modeling and documentation. However, representing non object-oriented languages with UML causes problems since UML is optimized for object-oriented languages. In this paper, we propose an approach to overcome such problem. If a non object-oriented language has a feature which can be mapped to object or class, the feature is extended to be used in UML diagrams. Then, new stereotype is assigned to distinguish the feature from original entities of UML. Such integrated UML representation with heterogeneous languages provides consistency for stakeholders since complex details of heterogeneous languages are hidden and encapsulated. An extended UML metamodel profile is proposed for consistent later application of the approach. An example is presented to show the effectiveness of the approach

Agile and systematic development is important in Web application methodology because clients expect their frequent requirement changes to be implemented rapidly and regularly. However, previous studies may not be suitable for such development. In this paper we propose a methodology for agile and somewhat systematic development of Web application. The methodology includes models, tools, and an agile process. The models extended from UML focus on the behavior of Web application. The agile process aims to have quick-to-market property and adaptability to requirement changes. Tools including process manager and Web modeler support process execution and modeling activity to guide developers in applying the process. An example of university assets management system and a comparison between our methodology and other processes are given to validate our methodology.