Search

Recently, various institutions have been conducting advanced programming education aimed at experiencing agile software development in the form of project-based learning (PBL). In the agile software development model, an essential part is the build process. In this study, we investigated students' build behaviors in agile software development PBL (SDPBL) by monitoring and collecting logs of the build process from 2013 to 2016. In our investigation, we collected two types of logs, the local build logs collected by each student's build in their own local programming environment, and remote build logs collected by any team member's commit in team repository. Based on our analysis of the build logs from 2013 to 2015, we found that the causes of remote build errors are related to both technical factors and communications among students in a team. In 2016, the instructors tried to educate to students the reason why the remote build error occur and how it can be resolved. As a result, in 2016, the number of remote build errors and the time required to solve the build errors decreased compared to previous years. It indicates a possibility that the student's comprehension of build error is effective on improving quality of software product and team development.

Developers often perform the repeating cycle of implementation and evaluation when they need to deal with the unfamiliar portion of the source code. This cycle is named as exploratory programming. We regard exploratory programming as an effective way not only to improve novice's programming skill but also to support educators in programming exercise in University. Because when novices often use the exploratory programming, it means novices struggle to solve their assignments. Therefore, educators should grasp which elements, APIs or blocks novices often used exploratory programming for. In this paper, firstly we propose the definition of novice's exploratory programming to collect logs of exploratory based on various granularity by novices. Secondly, we propose an algorithm based on our proposed definition to automatically detect exploratory programming behaviors. We also conducted a small case study. As a result of automatic detection, our proposed algorithm allows us to know what elements of program novices often feel difficult and struggle for.

To enhance the quality of software, many software development support tools and software development methodologies have been proposed. However, not all proposed tools and methodologies are widely used in software development. We assume that the evaluation of tools and methodologies by developers is different from the evaluation by researchers, and that this is one of the reasons why the tools and methodologies are not widely used. We analyzed the decision criteria of software developers as applied to the tools and methodologies, to clarify whether the difference exists or not. In behavioral economics, there are theories which assume people have biases, and they do not always act reasonably. In the experiment, we made a questionnaire based on behavioral economics, and collected answers from open source software developers. The results suggest that developers do not always act to maximize expected profit because of the certainty effect and ambiguity aversion. Therefore, we should reconsider the evaluation criteria of tools such as the f-measure or AUC, which mainly focus on the expected profit., SANER 2016 : 2016 IEEE 23rd International Conference on Software Analysis, Evolution, and Reengineering, 14-18 March 2016, Suita, Japan

Modern OSS projects have adopted Git to manage versions of their source code and GitHub for hosting their Git repositories. GitHub provides a characteristic feature notably pull request, and many projects adopt pull-based development model by using it. This development model offers an opportunity to review the source code before merging it into the mainstream. Getting acceptance of the pull request, any developer should strictly follow the flow of pull-based development. To follow the flow, she/he needs to use correctly Git commands. However, using these commands is complicated and requires further knowledge of them. In this paper, we conducted a large-scale survey of 1552 developers on GitHub to investigate the difficulty of the Git from the aspect of the pull request. The result shows developers struggle with 'git rebase -i' command tends not to perform re-ordering, compressing and dividing their commits.

In software development, multiple developers compose a team, and perform a development process. To succeed the development, understanding developers' characteristics are needed. However, there is no way to measure the characteristics of the developer by quantitative analysis. Therefore, a project manager often assigns team members based on his/her own sense, considering experience year of them. This paper proposes a measurement framework for developers' characteristics using quantitative historical data. The proposed framework is useful for measuring developers' characteristics and building a team based on quantitative analysis. We collected historical data from a PBL project for graduate students, and applied our framework to the collected data. As a result, our framework measured developers' characteristics suitability in our subjective view.

Developers often reuse existing software by copy and paste. Source code reuse improves productivity and software quality. On the other hand, source code reuse requires several professional skills to developers. In source code reuse, developers must locate reusable code fragments, and judge whether such reusable code is adequate to copy and paste into the source file under development. This paper presents extraction and analysis methods for developers' source code reuse behavior (copy and paste). Our method extracts developers' actual source code reuse (real copy and paste). Then, by using a code clone detection tool, the method extracts code fragments for (potential reuse). Our study of real and potential copy and paste provides a quantitative assessment for source code reuse by developers.

Developers often use null references for the returned values of methods (return null) in object-oriented languages. Although developers often use return null to indicate that a program does not satisfy some necessary conditions, it is generally felt that a method returning null is costly to maintain. One of the reasons for is that when a method receives a value returned from a method invocation whose code includes return null, it is necessary to check whether the returned value is null or not (null check). As developers often forget to write null checks, null dereferences occur frequently. However, it has not been clarified to what degree return null affects software maintenance during software evolution. This paper shows the influences of return null by investigating return null and null check in the evolution of source code. Experiments conducted on 14 open source projects showed that developers modify return null more frequently than return statements that do not include null. This result indicates that return null has a negative effect on software maintenance. It was also found that the size and the development phases of projects have no effect on the frequency of modifications on return null and null check. In addition, we found that all the projects in this experiment had from one to four null checks per 100 lines.

On the software development PBL (SDPBL), the implementation of firmly-fused development environment for students and monitoring environment for teachers are required in order to succeed in education. We have proposed the service, named "DaaS BADER" in compliance with demands from practical teachers to decrease the cost for preparation and maintenance of unified exercise environment and to monitor the progress of projects by teachers. In this paper, we have reported knowledge and information obtained by practical SDPBL and feedback contents for a student or group given by monitoring environment. Then, we have discussed the effectiveness of DaaS BADER from these results.

A variety of methods detecting code clones has been proposed before. In order to detect gapped code clones, AST-based technique, PDG-based technique, metric-based technique and text-based technique using the LCS algorithm have been proposed. However, each of those techniques has limitations. For example, existing AST-based techniques and PDG-based techniques require costs for transforming source files into intermediate representations such as ASTs or PDGs and comparing them. Existing metric-based techniques and text-based techniques using the LCS algorithm cannot detect code clones if methods or blocks are partially duplicated. This paper proposes a new method that detects gapped code clones using the Smith-Waterman algorithm to resolve those limitations. The Smith-Waterman algorithm is an algorithm for identifying similar alignments between two sequences even if they include some gaps. The authors developed the proposed method as a software tool named CDSW, and confirmed that the proposed method could resolve the limitations by conducting a quantitative evaluation with Bellon's benchmark.

In software maintenance, grasping characteristics of software systems by metrics measurement is a basic activity. However, metrics do not always represent characteristics of software systems. For example, Cyclomatic Complexity is a metric counting the number of branches in a given module, and it does not consider its content. One factor that Cyclomatic Complexity becomes large is the presence of repeated structures such as consecutive if-else structures. However, if such a structure is a repetition of simple operations, humans would not recognize a difficulty to understand the source code. In this paper, we propose performing preprocessing for metrics measurement and a methodology of the preprocessing. The proposed preprocessing simplifies repeated structures in source code. By applying the proposed preprocessing to metrics measurement, we can find low-understandability modules more efficiently. Also, we compared results of metrics measurement with and without the proposed preprocessing on open source software systems. As a result, we confirmed that metrics measurement with the proposed preprocessing was more useful to find low-understandability modules than without it.

Libraries created from commonly used functionalities offer a variety of benefits to developers. To locate such widely used functionalities, clone detection on a large corpus of source code could be useful. However, existing clone detection techniques did not address the creation of libraries. Therefore, existing clone detectors are sometimes unbefitting to detect candidates to be included in libraries. This paper proposes a method-based clone detection technique focusing on building libraries. This method-level granularity is appropriate for building libraries because a method composes a functionally coherent unit, and so it can be easily pulled up into libraries. Also, such a granularity realizes a scalable detection on huge data sets. Our experimental results on a huge data set (360 million lines of code, 13,000 projects) showed that the proposed technique could detect functional clones which might be beneficial on the creation of libraries within a short time frame.

It is crucial for educators to understand pitfalls for novice programmers in programming education at computer science course. By giving well-timed advice to students who fall into a pitfall, educators are able to achieve efficient teaching and keep up their students' motivation. However, so far, it is less well-understood how novice students edit source code and why they fall into a pitfall. In this paper, we analyzed coding patterns of novice students empirically. We collected programming activities by students on exercises of programming course, and then performed qualitative and quantitative analysis. In qualitative analysis, experienced programmers analyzed patterns of the novice programmers manually. In quantitative analysis, we focused on transtions of the edit distance between a source code of each student under development and a correct source code in a programming class. As a result, we confirmed coding patterns of novice programmers in case of falling into pitfalls, and the characteristics of transitions of edit distance metric in the case that novice students had faced difficulty in understanding the exercise.

A variety of code clone detection methods have been proposed before now. However, only a small part of them is widely used. Widely-used methods are line-based and token-based ones. They have high scalability because they neither require deep source code analysis nor constructing complex intermediate structures for the detection. High scalability is one of the big advantages in code clone detection tools. On the other hand, line/token-based detections yield many false positives. One of the factors is the presence of repeated instructions in the source code. For example, herein we assume that there are consecutive three printf statements in C source code. If we apply a token-based detection to them, the former two statements are detected as a code clone of the latter two statements. However, such overlapped code clones are redundant and so not useful for developers. In this paper, we propose a new detection method that is free from the influence of the presence of repeated instructions. The proposed method transforms every of repeated instructions into a special form, and then it detects code clones using a suffix array algorithm. The transformation prevents many false positives from being detected. Also, the detection speed remains. The proposed detection method has already been developed as a software tool, FRISC. We confirmed the usefulness of the proposed method by conducting a quantitative evaluation of FRISC with Bellon's oracle.

In order to reduce coupling and increase cohesion, we refactor program source code. Previous research efforts for suggesting candidates of such refactorings are based on static analysis, which obtains relations among classes or methods from source code. However, these approaches cannot obtain runtime information such as repetition count of loop, dynamic dispatch and actual execution path. Therefore, previous approaches might miss some refactoring opportunities. To tackle this problem, we propose a technique to find refactoring candidates by analyzing method traces. We have implemented a prototype tool based on the proposed technique and evaluated the technique on two software systems. As a result, we confirmed that the proposed technique could detect some refactoring candidates, which increase code quality.

This paper summarized experiences of practical software development exercise in PBL style activities from organizer perspective. The object of this PBL is nurturing advanced knowledge as advanced information and communication technology (ICT) engineers. A main pillar of this report is trace the 5-year history of three sub environments such as development, development support and teaching support environment which are badly need to hold our software development PBL, from problem and its solutions viewpoint.

In recent years, the increased failure originated in the software defects, in various information systems causes a serious social problem. In order to build a high-quality software, cultivation of ICT (Information and Communication Technology) human resources like a software engineer is required. A software development PBL (Project-based Learning) is the educational technique which lets students acquire knowledge and skill spontaneously through practical software development. In PBL, on the other hand, it is difficult to evaluate not only the quality of the product but also the quality of the development process in the project. In this paper, we propose the student evaluation metrics to assess the development process in PBL. The student evaluation metrics represent LOC (Lines of Code) and development time for each product developed by a student. By using online storage, these metrics can be measured and visualized automatically. We conducted an experiment to evaluate the accuracy of the metrics about development time. As a result, we confirmed that development time metrics can be measured with approximately 20% of error.

Refactoring is important for efficient software maintenance. However, manual operations for refactoring are complicated, and human-related errors easily occur. Tool support can help users to apply such a complicated refactoring. This paper proposes a refactoring support tool with Form Template Method pattern. The developed tool automatically identifies method pairs that can be refactored with Form Template Method, and suggests information that is required for Form Template Method application. It also has a function that metrics-based filtering for detected method pairs. The function helps users to select method pairs that should be refactored.

When multiple sensor-driven services are deployed in the same environment, execution of a service may trigger other services, successively. Such chain reactions of services often cause undesirable feature interactions. This paper presents a framework that can characterize and detect the service chains within the home network system (HNS). We first introduce the ECA rules to describe the services, and then propose an environment effect model to capture how each device in the HNS affects the environment. Finally, we develop an algorithm that detects the service chains with concrete enabling conditions. A case study with 7 practical services shows that the proposed method successfully detects 11 service chains, in which 6 harmful feature interactions are identified.

The sensor as a service is an emerging application of the services computing. However, how to implement such sensor services efficiently and reliably is an open issue. This paper presents an application framework, called Sensor Service Framework (SSF), that supports developers to build and deploy sensor services in the home network system (HNS). The SSF prescribes device-neutral features and APIs for the sensor devices to be deployed as Web services. Writing a small amount of code with the SSF, the developer can easily deploy any sensor device as a service in the HNS. The sensor service can provide a standardized access to heterogeneous sensor devices, as well as a context management service with user-defined conditions. We then present a {\em sensor mashup platform (SMuP)}, which allows the dynamic composition of the existing sensor services. To support non-expert developers, we also implemented a GUI front-end, called Sensor Service Binder (SSB). The proposed technologies are implemented and evaluated in an actual HNS to demonstlate practical feasibility.

To support legacy migration to service-oriented architecture (SOA), this paper presents a method that derives candidates of SOA services from procedural programs. In SOA, every service is supposed to be a process (procedure) with (1) open interface, (2) self-containedness, (3) coarse granularity for business. We identify such services from the source code and its data flow diagram (DFD), by analyzing data and control dependency among processes. Specifically, we first obtain the DFD with reverse-engineering techniques. For each layer of the DFD we classify every data flow into three categories. Using the data category and control among procedures, we characterize four types of dependency. We finally apply six rules that aggregate mutually dependent procedures and extract them as a service. A case study with a liquor shop inventory control system extracts service candidates with various granularity.

The home network system (HNS) consists of networked household appliances, intended to provide value-added services. The conventional HNS has been built on the single- vendor system, which severely limits potential of the HNS. To overcome the problem, this paper presents a method that constructs the HNS with multi-vendor appliances. The proposed method first defines vendor-neutral standard services, with which various HNS applications and services are developed. Then, we exploit a dynamic service binding mechanism, which binds each standard service on a vendor- specific API of an appliance during run-time. With this mechanism, common HNS applications and services can be achieved by various combinations of multi-vendor appliances. Moreover, replacing any appliance with another never affects the execution of the applications. We have implemented the proposed method using Apache Axis Web services and Rhino JavaScript engine. The experimental evaluation showed that our implementation works well for a practical HNS with sufficiently small overhead.

The technology of a home network system (HNS) allows integration of several kinds of home appliances to provide a user with value-added integrated services. Development of the integrated HNS services requires implementation of the appliance components (with APIs) and the services, according to each home-network environment. There are various implementation standards such as DLNA, ECHONET, OSGi and Jinifor the HNS applications. Therefore, even if a developer can choose the optimal one, it's very difficult to develop the integrated services by composing a new HNS implementation. In this paper, we propose a model-driven development of integrated HNS service applications. In our former manuscript, platform-independent design language for verifying HNS service scenarios was proposed. Our model-driven development method uses this design language as a meta-model of integrated HNS services. By model transformation to concrete implementation together with verification by SMV (symbolic model checking), productivity and quality of this kind of HNS applications are improved., APSEC'06 : 2006 13th Asia Pacific Software Engineering Conference, 6-8 Dec. 2006, Kanpur, India

In the next-generation home network systems (HNS), interoperability among multi-vendor appliances is a challenging issue to implement value-added integrated services. This paper presents a service-oriented framework to enable both evolution of HNS and the appliance interoperability. The key idea is to construct the integrated services by combining the existing services deployed by the appliances. This allows to eliminate the reference model, which had been an obstacle of the evolution of the HNS., IWPSE'05 : Eighth International Workshop on Principles of Software Evolution, 5-6 Sept. 2005, Lisbon, Portugal

This paper presents a framework that adapts the conventional home electric appliances with the infrared remote controls (legacy appliances) to the emerging home network system (HNS). The proposed method extensively uses the concept of service-oriented architecture to improve programmable interoperability among multi-vendor appliances. We first prepare APIs that assist a PC to send infrared signals to the appliances. We then aggregate the APIs within self-contained service components, so that each of the component achieves a logical feature independent of device(or vendor)-specific operations. The service components are finally exported to the HNS as Web services. Thus, the legacy appliances can be used as distributed components with open interfaces. To demonstrate the effectiveness, we also implement an actual HNS and integrated services with multi-vendor legacy appliances, ICWS'06 : 2006 IEEE International Conference on Web Services, 18-22 Sept. 2006, Chicago, IL, USA