Powered by
Conference Publishing Consulting

International Workshop on Innovative Software Development Methodologies and Practices (InnoSWDev), November 16, 2014, Hong Kong, China

InnoSWDev 2014 – Proceedings

Contents - Abstracts - Authors

International Workshop on Innovative Software Development Methodologies and Practices (InnoSWDev)


Title Page

On behalf of the Program Committee, welcome to the Workshop on Innovative Software Development Methodologies and Practices (InnoSWDev 2014), November 16, 2014, at Hong Kong, China, co-located with ICSE 2014.

New Paradigm

Software Engineering for Multi-tenancy Computing Challenges and Implications
Jia Ru, John Grundy, and Jacky Keung
(Swinburne University of Technology, Australia; City University of Hong Kong, China)
Multi-tenancy is a cloud computing phenomenon. Multiple instances of an application occupy and share resources from a large pool, allowing different users to have their own version of the same application running and coexisting on the same hardware but in isolated virtual spaces. In this position paper we survey the current landscape of multi-tenancy, laying out the challenges and complexity of software engineering where multi-tenancy issues are involved. Multi-tenancy allows cloud service providers to better utilise computing resources, supporting the development of more flexible services to customers based on economy of scale, reducing overheads and infrastructural costs. Nevertheless, there are major challenges in migration from single tenant applications to multi-tenancy. These have not been fully explored in research or practice to date. In particular, the reengineering effort of multi-tenancy in Software-as-a-Service cloud applications requires many complex and important aspects that should be taken into consideration, such as security, scalability, scheduling, data isolation, etc. Our study emphasizes scheduling policies and cloud provisioning and deployment with regards to multi-tenancy issues. We employ CloudSim and MapReduce in our experiments to simulate and analyse multi-tenancy models, scenarios, performance, scalability, scheduling and reliability on cloud platforms.

Publisher's Version Article Search
Enhanced N-Version Programming and Recovery Block Techniques for Web Service Systems
Kuan-Li Peng, Chin-Yu Huang, Pin-Heng Wang, and Chao-Jung Hsu
(National Tsing Hua University, Taiwan; Alpha Networks, Taiwan; Altek, Taiwan)
In recent years, web services (WS’s) have been widely used to support interoperable machine-to-machine interaction over a network. In order to ensure a reliable WS system, a number of fault tolerance designs have been proposed. It is known that network connection and hardware devices may fail. In addition, the acceptance test (AT) as well as the decision mechanism (DM), which are common in fault tolerance designs, could also fail unexpectedly. Such uncertainties may affect the reliability of a WS-based system but have not yet been carefully considered in reliability modeling. Therefore, we propose extended NVP (ENVP) and extended RB (ERB) for the reliability analysis. Various operations of ENVP and ERB are discussed, and a simulation procedure is implemented to evaluate the system reliability and the failure probability of fault-tolerant WS-based systems. The experimental results show a high degree of correlation between the numbers of AT’s and the reliability improvements. The proposed fault tolerance designs could improve the system reliability, and the simulation procedure could also help in exploring appropriate configurations of fault tolerance designs for practitioners.

Publisher's Version Article Search

Testing and Verification

Model Checking Partial Software Product Line Designs
Yufeng Shi, Ou Wei, and Yu Zhou
(Nanjing University of Aeronautics and Astronautics, China)
Software product line (SPL) maximizes commonality between software products to reduce cost and improve productivity, where each product is represented by a selection of features that corresponds to particular customer requirements. SPL has been widely applied in critical systems such as communications, automobile, and aerospace, and ensuring correctness of the system is thus of great importance. In this paper, we consider model checking partial software product line designs, i.e., the incomplete designs in the early stage of software development, where the design decisions for a feature may be unknown. This enables detecting design errors earlier, reducing the cost of later development of final products. To this end, we first propose bilattice-based feature transitions systems (BFTSs) for modeling partial software product line designs, which support description of uncertainty and preserve features as a first class notion. We then express system behavioral properties using ACTL formulas and define its semantics over BFTSs. Finally, to leverage the power of existing model checking engine for verification, we provide the procedures that translate BFTSs and ACTL formulas to the inputs of the symbolic model checker Chek. We implement our approach and illustrate its effectiveness on a benchmark from literature.

Publisher's Version Article Search
Software Reliability Analysis Considering the Variation of Testing-Effort and Change-Point
Syuan-Zao Ke, Chin-Yu Huang, and Kuan-Li Peng
(Ability Enterprise, Taiwan; National Tsing Hua University, Taiwan)
It is commonly recognized that software development is highly unpredictable and software quality may not be easily enhanced after software product is finished. During the software development life cycle (SDLC), project managers have to solve many technical and management issues, such as high failure rate, cost over-run, low quality, late delivery, etc. Consequently, in order to produce robust and reliable software product(s) on time and within budget, project managers and developers have to appropriately allocate limited development- and testing-effort and time. In the past, the distribution of testing-effort or manpower can typically be described by the Weibull or Rayleigh model. Practically, it should be noticed that development environments or methods could change due to some reasons. Thus when we plan to perform software reliability modeling and prediction, these changes or variations occurring in the development process have to be taken into consideration. In this paper, we will study how to use the Parr-curve model with multiple change-points to depict the consumption of testing-effort and how to perform further software reliability analysis. The applicability and performance of our proposed model will be demonstrated and assessed through real software failure data. Experimental results are analyzed and compared with other existing models to show that our proposed model gives better predictions.

Publisher's Version Article Search
Program Structure Aware Fault Localization
Heng Li, Yuzhen Liu, Zhenyu Zhang, and Jian Liu
(Institute of Software at Chinese Academy of Sciences, China; North China Electric Power University, China)
Software testing is always an effective method to show the presence of bugs in programs, while debugging is never an easy task to remove a bug from a program. To facilitate the debugging task, statistical fault localization estimates the location of faults in programs automatically by analyzing the program executions to narrow down the suspicious region. We observe that program structure has strong impacts on the assessed suspiciousness of program elements. However, existing techniques inadequately pay attention to this problem. In this paper, we emphasize the biases caused by program structure in fault localization, and propose a method to address them. Our method is dedicated to boost a fault localization technique by adapting it to various program structures, in a software development process. It collects the suspiciousness of program elements when locating historical faults, statistically captures the biases caused by program structure, and removes such an impact factor from a fault localization result. An empirical study using the Siemens test suite shows that our method can greatly improve the effectiveness of the most representative fault localization Tarantula.

Publisher's Version Article Search
Toward a Methodology to Expose Partially Fixed Concurrency Bugs in Modified Multithreaded Programs
To Tsui, Shangru Wu, and W. K. Chan
(City University of Hong Kong, China)
Many multithreaded programs incur concurrency bugs. A modified version of such a program, which the exposed concurrency bug is deemed fixed, should be subject to further testing to validate whether the concurrency bug may only be partially fixed. In this paper, we present a similarity-based regression testing methodology to address this problem. It is based on the notions of similar execution contexts of events and bug signatures. To the best of our knowledge, it also presents the first regression testing technique that manipulates thread schedules using a similarity-based active testing strategy.

Publisher's Version Article Search

System Development and Management

Cloud-Based Support for Global Software Engineering: Potentials, Risks, and Gaps
Mohammed Al-qadhi and Jacky Keung
(City University of Hong Kong, China)
Global Software Engineering (GSE) aims at utilizing global expertise and reducing time-to-market and costs for software development. However, GSE faces serious challenges related to the communication, coordination and provision of development environments for geographically distributed GSE sites, resulting in increased costs. Nowadays, cloud computing offers a cost-effective and a handy solution to provide computing support for global business. In particularly, it provides potential and viable solutions to address concerns and challenges in GSE. We have reviewed the relevant literature on cloud-based support for GSE and identified a set of pros and cons for supporting GSE with cloud services. We also present some recommendations to increase the trustworthiness and productivity with cloud-based support for GSE. This paper outlines the potential benefits and risks of cloud computing to GSE and identifies some gaps that need to be addressed by cloud-based support towards more trustworthy and productive work environment for GSE. This will open windows of opportunities for tailoring the solution utilizing cloud-based support for GSE.

Publisher's Version Article Search
Scaling up Analogy-Based Software Effort Estimation: A Comparison of Multiple Hadoop Implementation Schemes
Passakorn Phannachitta, Jacky Keung, Akito Monden, and Kenichi Matsumoto
(NAIST, Japan; City University of Hong Kong, China)
Analogy-based estimation (ABE) is one of the most time consuming and compute intensive method in software development effort estimation. Optimizing ABE has been a dilemma because simplifying the procedure can reduce the estimation performance, while increasing the procedure complexity with more sophisticated theory may sacrifice an advantage of the unlimited scalability for a large data input. Motivated by an emergence of cloud computing technology in software applications, in this study we present 3 different implementation schemes based on Hadoop MapReduce to optimize the ABE process across multiple computing instances in the cloud-computing environment. We experimentally compared the 3 MapReduce implementation schemes in contrast with our previously proposed GPGPU approach (named ABE-CUDA) over 8 high-performance Amazon EC2 instances. Results present that the Hadoop solution can provide more computational resources that can extend the scalability of the ABE process. We recommend adoption of 2 different Hadoop implementations (Hadoop streaming and RHadoop) for accelerating the computation specifically for compute-intensive software engineering related tasks.

Publisher's Version Article Search
A New Business Model of Custom Software Development for Agile Software Development
Yoshihito Kuranuki, Tsuyoshi Ushio, Tsutomu Yasui, and Susumu Yamazaki
(SonicGarden, Japan; SimpleArchitect, Japan; Eiwa System Management, Japan; University of Kitakyushu, Japan)
In this paper, we propose a new business model for custom software development industry utilizing agile software development to embrace changes. Traditional business model usually does not work well with agile software development because it mandate up-front man-month estimation based on a fixed scope. Our new model proposes a solution with two notable features; fixed monthly subscription and weekly agreement of what to provide. We successfully applied the new business model to more than 20 cases over 3 years and this paper describes one of them.

Publisher's Version Article Search
Developing Enterprise Mobile Applications the Easy Way
Aharon Abadi, Yael Dubinsky, Andrei Kirshin, Yossi Mesika, Idan Ben-Harrush, and Uzy Hadad
(IBM Research, Israel; Academic College of Tel Aviv-Yaffo, Israel)
Constructing a mobile application in the enterprise is expensive and time consuming. On average, deploying a mobile application is estimated at one week of effort per screen. We present an evaluation of NitroGen, a platform-independent tool for constructing mobile solutions. The tool provides a consumable integrated set of capabilities aimed at reducing development and maintenance costs. NitroGen is a mostly codeless, cloud-based, platform for visually constructing mobile applications. We demonstrate how students with some skills in web development and no skills in mobile development have successfully learned and used NitroGen to implement a small-scale three-screen application, which uses existing back-end services—all in less than 90 minutes.

Publisher's Version Article Search

Software Modeling, Analysis with Visualization Approach

Context-Sensitive Detection of Information Exposure Bugs with Symbolic Execution
Paul Muntean, Claudia Eckert, and Andreas Ibing
(TU München, Germany)
Static analysis tools used for detecting information exposure bugs can help software engineers detecting bugs without introducing run-time overhead. Such tools can make the detection of information-flow bugs faster and cheaper without having to provide user input in order to trigger the bug detection. In this paper we present a bug-detection tool for detecting information exposure bugs in C/C++ programs. Our tool is context-sensitive and uses static code analysis for bug detection. We developed our bug finding tool as a Eclipse plug-in in order to easily integrate it in software development work flows. The bug reports provide user friendly visualizations that can be easily traced back to the location where the bug was detected. We discuss one static analysis approach for detecting information exposure bugs and relate briefly the usability of our bug testing tool to empirical research. We conducted an empirical evaluation based on 90 test programs which were selected from the Juliet test suite for C/C++ code. We reached a true-positive coverage of 94.4% in 121 seconds for 90 test programs having a total of 12589 source code lines.

Publisher's Version Article Search
Supporting Clone Analysis with Tag Cloud Visualization
Manamu Sano, Eunjong Choi, Norihiro Yoshida, Yuki Yamanaka, and Katsuro Inoue
(Osaka University, Japan; Nagoya University, Japan)
So far, a lot of techniques have been developed on the detection of code clones (i.e., duplicated code) in large-scale source code. Currently, the code clone research community is gradually shifting its focus of attention from the detection to the management (e.g., clone refactoring). During clone management, developers need to understand how and why code clones are scattered in source code, and then decide how to handle those code clones. In this paper, we present a clone analysis tool with tag cloud visualization. This tool is aimed at helping to understand why code clone are concentrated in a part of a software system by generating tag clouds from a collection of identifier names in source code.

Publisher's Version Article Search
Sketch-Based Gradual Model-Driven Development
Peiyuan Li, Naoyasu Ubayashi, Di Ai, Yu Ning Li, Shintaro Hosoai, and Yasutaka Kamei
(Kyushu University, Japan)
This paper proposes an abstraction-aware reverse engineering method in which a developer just makes a mark on an important code region as if he or she draws a quick sketch on the program list. A support tool called iArch slices a program from marked program points and generates an abstract design model faithful to the intention of the developer. The developer can modify the design model and re-generate the code again while preserving the abstraction level and the traceability. Archface, an interface mechanism between design and code, plays an important role in abstraction-aware traceability check. If the developer wants to obtain a more concrete design model from the code, he or she only has to make additional marks on the program list. We can gradually transition to model-driven development style.

Publisher's Version Article Search
An Empirical Study of BM25 and BM25F Based Feature Location Techniques
Zhendong Shi, Jacky Keung, and Qinbao Song
(Xi'an Jiaotong University, China; City University of Hong Kong, China)
Feature location is a software comprehension activity which aims at identifying source code entities that implement functionalities. Manual feature location is a labor-insensitive task, and developers need to find the target entities from thousands of software artifacts. Recent research has developed automatic and semiautomatic methods mainly based on Information Retrieval (IR) techniques to help developers locate the entities which are textually similar to the feature. In this paper, we focus on individual IR-based methods and try to find a suitable IR technique for feature location, which could be chosen as a part of hybrid methods to achieve good performance. We present two feature location approaches based on BM25 and its variant BM25F algorithm. We compared the two algorithms to the Vector Space Model (VSM), Unigram Model (UM), and Latent Dirichlet Allocation (LDA) on four open source projects. The result shows that BM25 and BM25F are consistently better than other IR methods such as VSM, UM and LDA on the four selected software systems in their best configurations respectively.

Publisher's Version Article Search

proc time: 0.7