ICSE Posters
June 5th, Wednesday, 4:00 pm - 6:30 pm
Room: TBA
APISynth: A New Graph-Based API Recommender System
Chen Lv, Wei Jiang, Yue Liu, and Songlin Hu
(University of Chinese Academy of Sciences, China; Institute of Computing Technology at Chinese Academy of Sciences, China; Greatwall Drilling Company, China)
Current API recommendation tools yield either good recall ratio or good precision, but not both. A tool named APISynth is proposed in this paper by utilizing a new graph based approach. Preliminary evaluation demonstrates that APISynth wins over the state of the art with respect to both the two criteria.
Shedding Light on Distributed System Executions
Jenny Abrahamson, Ivan Beschastnikh, Yuriy Brun, and Michael D. Ernst
(Facebook, USA; University of British Columbia, Canada; University of Massachusetts, USA; University of Washington, USA)
In a distributed system, the hosts execute concurrently, generating asynchronous logs that are challenging to comprehend. We present two tools: ShiVector to transparently add vector timestamps to distributed system logs, and ShiViz to help developers understand distributed system logs by visualizing them as space-time diagrams. ShiVector is the first tool to offer automated vector timestamp instrumentation without modifying source code. The vector-timestamped logs capture partial ordering information, useful for analysis and comprehension. ShiViz space-time diagrams are simple to understand and interactive — the user can explore the log through the visualization to understand complex system behavior. We applied ShiVector and ShiViz to two systems and found that they aid developers in understanding and debugging.
Fault Localization for Build Code Errors in Makefiles
Jafar Al-Kofahi, Hung Viet Nguyen, and Tien N. Nguyen
(Iowa State University, USA)
Building is an important process in software development. In large software projects, build code has a high level of complexity, churn rate, and defect proneness. While several automated approaches exist to help developers in localizing faults in traditional source code and in detecting code smells in build code, fault localization techniques have not yet been developed for build code. In this work, we introduce MkFault, a tool to localize errors resulting in build crashes. MkFault monitors the execution traces from GNU Make statements that produce concrete build rules and the original code locations for each component of a rule (i.e., target, prerequisites, and recipe). It then uses a novel ranking algorithm to give suspiciousness scores to the original statements in the Makefile. In our empirical evaluation with real faults, we show that MkFault can help localize faults in Make code with high accuracy.
Avoiding Deadlocks using Stalemate and Dimmunix
Surabhi Pandey, Sushanth Bhat, and Vivek Shanbhag
(IIIT Bangalore, India)
The execution of a concurrent Java program can deadlock if its threads attempt to acquire shared locks in cyclic order. The JVM permits such behaviour. Research has demonstrated that such deadlocks can be predicted through static analysis. It is also known that a tool like Dimmunix helps to avoid deadlocks whose deadlock patterns (fingerprints) are known. The current work combines both approaches: conducting static analysis to predict possible deadlocks and provide their corresponding fingerprints to Dimmunix. These fingerprints forewarn Dimmunix of all deadlock possibilities rather than it learn about them one at a time. For our experiments we use 8 deadlock programs that were developed based upon deadlock predictions from static analysis of the entire JRE by a tool called Stalemate. We design a process to generate Dimmunix fingerprints from deadlock predictions.
Assuring System Goals under Uncertainty with Active Formal Models of Self-Adaptation
M. Usman Iftikhar and Danny Weyns
(Linnaeus University, Sweden)
Designing software systems with uncertainties, such as incomplete knowledge about changing system goals, is challenging. One approach to handle uncertainties is self-adaptation, where a system consists of a managed system and a managing system that realizes a feedback loop. The promise of self-adaptation is to enable a system to adapt itself realizing the system goals, regarding uncertainties. To realize this promise it is critical to provide assurances for the self-adaptive behaviours. Several approaches have been proposed that exploit formal methods to provide these assurances. However, an integrated approach that combines: (1) seamless integration of offline and online verification (to deal with inherent limitations of verification), with (2) support for runtime evolution of the system (to deal with new or changing goals) is lacking. In this paper, we outline a new approach named Active FORmal Models of Self-adaptation (ActivFORMS) that aims to deal with these challenges. In ActivFORMS, the formal models of the managing system are directly deployed and executed to realize self-adaptation, guaranteeing the verified properties. Having the formal models readily available at runtime paves the way for: (1) incremental verification during system execution, and (2) runtime evolution of the self-adaptive system. Experiences with a robotic system show promising results.
Timing Challenges in Automotive Software Architectures
Licong Zhang, Reinhard Schneider, Alejandro Masrur, Martin Becker, Martin Geier, and Samarjit Chakraborty
(TU München, Germany; TU Chemnitz, Germany)
Most of the innovation in the automotive domain is now in electronics and software, which has led to several million lines of code in today's high-end cars. However, in contrast to software in the general purpose computing domain -- where mostly functional correctness is of concern -- timing predictability of automotive software is an important problem which is still largely unsolved. More importantly, this problem is solely addressed within the embedded systems domain with little or no participation from the mainstream software engineering community. The goal of this poster is to highlight some of the aspects of timing analysis of automotive software, as an attempt to involve the broader software engineering research community in this problem.
An Adaptive Bayesian Approach for URL Selection to Test Performance of Large Scale Web-Based Systems
Alim Ul Gias and Kazi Sakib
(University of Dhaka, Bangladesh)
In case of large scale web-based systems, scripts for performance testing are updated iteratively. In each script, multiple URLs of the system are considered depending on intuitions that those URLs will expose the performance bugs. This paper proposes a Bayesian approach for including a URL to a test script based on its probability of being time intensive. As the testing goes on the scheme adaptively updates its knowledge regarding a URL. The comparison with existing methods shows that the proposed technique performs similar in guiding applications towards intensive tasks, which helps to expose performance bugs.
DEECo: An Ecosystem for Cyber-Physical Systems
Rima Al Ali, Tomas Bures, Ilias Gerostathopoulos, Petr Hnetynka, Jaroslav Keznikl, Michal Kit, and Frantisek Plasil
(Charles University, Czech Republic)
In this work we tackle the problem of designing and developing software-intensive cyber-physical systems (CPS), which are large distributed systems of collaborating elements that closely interact with the physical world, such as intelligent transportation systems and crowdsourcing applications. Due to their specific constraints, such as extreme dynamism and continuous evolution of the physical substratum, and requirements, such us open-endedness and adaptability, CPS introduce many new challenges for software engineering. In response, we present a tailored ecosystem of software engineering models, methods, and tools. This ecosystem is centered on the DEECo component model, which we have proposed specifically for architecting software-intensive CPS.
Calibrating Use Case Points
Ali Bou Nassif, Luiz Fernando Capretz, and Danny Ho
(University of Western Ontario, Canada; NFA Estimation, Canada)
An approach to calibrate the complexity weights of the use cases in the Use Case Points (UCP) model is put forward. The size metric used is the Use Case Points (UCP) which can be calculated from the use case diagram along with its use case scenario as described in the UCP model. The approach uses a neural network with fuzzy logic to tune the complexity weights.
The MechatronicUML Method: Model-Driven Software Engineering of Self-Adaptive Mechatronic Systems
Steffen Becker, Stefan Dziwok, Christopher Gerking, Christian Heinzemann, Wilhelm Schäfer, Matthias Meyer, and Uwe Pohlmann
(University of Paderborn, Germany; Fraunhofer IPT, Germany)
The software of mechatronic systems interacts with the system's physical environment. In such systems, an incorrect software may cause harm to human life. As a consequence, software engineering methods for developing such software need to enable developers to effectively and efficiently proof their correctness. This is further complicated by additional characteristics of mechatronic systems as self-adaptation and coordination with other systems. In this poster, we present MechatronicUML which is a model-driven software engineering method that especially considers these characteristics of self-adaptive mechatronic systems.
Model-Driven Development of Diverse User Interfaces
Zhiyi Ma, Wei Zhang, and Chih-Yi Yeh
(Peking University, China)
Developing and maintaining user interfaces of an application for various devices is usually laborious. This paper discusses how to build diverse user interfaces based on model-driven development.
Statistical Learning of API Mappings for Language Migration
Anh Tuan Nguyen, Hoan Anh Nguyen, Tung Thanh Nguyen, and Tien N. Nguyen
(Iowa State University, USA; Utah State University, USA)
The process of migrating software between languages is called language migration or code migration. To reduce manual effort in defining the rules of API mappings for code migration, we propose StaMiner, a data-driven model that statistically learns the mappings between API usages from the corpus of the corresponding methods in the client code of the APIs in two languages.
Asymmetric Software Structures in the Linux Kernel
Lei Wang, Ping Wang, and Zhen Wang
(Beihang University, China)
We investigated the asymmetry in the structure of complex software. After studying the degree distribution of the call graphs corresponding to the Linux kernel modules of 223 different versions, we found the asymmetry between the in-degree and out-degree distributions. After analyzing the behaviors of the newly added nodes in each version, we found that the preferential attachment behaviors of the new nodes are not only related with the degree of nodes, also related with the "age" of nodes, especially in the out-degree. In addition, the new nodes tend to cluster in Linux kernel.
Towards Designing Assistive Software Applications for Discrete Trial Training
Valerie Picardo, Samuel Metson, Rashina Hoda, Robert Amor, Angela Arnold-Saritepe, Rebecca Sharp, and Denys Brand
(University of Auckland, New Zealand)
Discrete Trial Training (DTT) is one of the most effective training methods for children diagnosed with Autism. Traditional DTT suffers from limitations of inconsistencies on account of human error, disruptions due to in-session data collection by trainers, and difficulties of producing physical within-stimulus prompts. Current software solutions either support sole child usage thereby eliminating the social interaction benefits of DTT or lack automated data collection. Designed by an inter-disciplinary team of software engineers, HCI, and psychology experts and certified behaviour analysts for a touch-tabletop, DTTAce is an assistive-software that provides digital consistency and integrity and supports customization of trials, automated data collection, and within-stimulus prompts while preserving natural interactions and the social nature of DTT. It is an important step towards designing effective assistive software for Discrete Trial Training.
An Optimized Design Approach for Extending HMI Systems with Mobile Devices
Manasvi Jain, Rahul Raj CP, and Seshubabu Tolety
(Siemens, India)
Remote monitoring and controlling of industrial machines have proven to be a necessary requirement for many engineering domains. HMI panels are already successful in providing proper control for such machines/ layouts. Many organizations are now utilizing new and trendy smart phones to access their legacy systems remotely. In this paper, we elicit a viable approach for extending HMI systems with the smart phones and tablets. This approach overcomes the challenges of explicit mobile application design approaches and provides appropriate application architecture for mobile extension providers.
Proposing a Theory of Gamification Effectiveness
Bilal Amir and Paul Ralph
(Sur University College, Oman; Lancaster University, UK)
Gamification informally refers to making a system more game-like. More specifically, gamification denotes applying game mechanics to a non-game system. We theorize that gamification success depends on the game mechanics employed and their effects on user motivation and immersion. The proposed theory may be tested using an experiment or questionnaire study.
Modeling and Model Checking by Modular Approach
Mo Xia, Guiming Luo, and Mian Sun
(Tsinghua University, China)
Model checking is a common formal verification technique, but it is only applicable to white box systems. In order to allow users without much formal verification expertise to use model checking easily, this paper proposes a modular approach for software modeling and model checking. Efficiency, correctness, and reusability are our main concerns. A hierarchical model is constructed for a system by modules, and it is translated into the specific model checking codes. The M^3C tool is implemented to support our approach, and it is successfully applied to actual industrial cases, as well as to some cases in the literature.
Hybrid Test Data Generation
Zicong Liu, Zhenyu Chen, Chunrong Fang, and Qingkai Shi
(Nanjing University, China)
Many automatic test data generation techniques have been proposed in the past decades. Each technique can only deal with very restrictive data types so far. This limits the usefulness of test data generation in practice. We present a preliminary approach on hybrid test data generation, by combining Random Strategy (RS), Dynamic Symbolic Execution (DSE), and Search-based Strategy (SBS). It is expected to take advantage of the state-of-the-arts to enhance the robustness and scalability, in terms of different types of test data.
Software Defect Prediction Based on Collaborative Representation Classification
Xiao-Yuan Jing, Zhi-Wu Zhang, Shi Ying, Feng Wang, and Yang-Ping Zhu
(Wuhan University, China; Nanjing University of Posts and Telecommunications, China)
In recent years, machine learning techniques have been successfully applied into software defect prediction. Although they can yield reasonably good prediction results, there still exists much room for improvement on the aspect of prediction accuracy. Sparse representation is one of the most advanced machine learning techniques. It performs well with respect to signal compression and classification, but suffers from its time-consuming sparse coding. Compared with sparse representation, collaborative representation classification (CRC) can yield significantly lower computational complexity and competitive classification performance in pattern recognition domains. To achieve better defect prediction results, we introduce the CRC technique in this paper and propose a CRC based software defect prediction (CSDP) approach. We first design a CRC based learner to build a prediction model, whose computational burden is low. Then, we design a CRC based predictor to classify whether the query software modules are defective or defective-free. Experimental results on the widely used NASA datasets demonstrate the effectiveness and efficiency of the proposed approach.
