Walid M. Ibrahim

An Empirical Study on Inconsistent Changes to Code Clones at Release Level

Current research on code clones tries to address the question whether or not code clones are harmful for the quality of software. As most of these studies are based on the fine-grained analysis of inconsistent changes at the revision level, they capture much of the chaotic and experimental nature inherent to any ongoing software development process. Conclusions drawn from the inspection of highly fluctuating and short-lived clones are likely to exaggerate the ill effects of inconsistent changes. To gain a broader perspective, we perform an empirical study on the effect of inconsistent changes on software quality at the release level. Based on a case study on two open source software systems, we observe that only 1% to 3% of inconsistent changes to clones introduce software defects, as opposed to substantially higher percentages reported by other studies. Our findings suggest that developers are able to effectively manage and control the evolution of cloned code at the release level.

Predicting Re-opened Bugs: A Case Study on the Eclipse Project

Bug fixing accounts for a large amount of the software maintenance resources. Generally, bugs are reported, fixed, verified and closed. However, in some cases bugs have to be re-opened. Re-opened bugs increase maintenance costs, degrade the overall user-perceived quality of the software and lead to unnecessary rework by busy practitioners. In this paper, we study and predict re-opened bugs through a case study on the Eclipse project. We structure our study along 4 dimensions: 1) the work habits dimension (e.g., the weekday on which the bug was initially closed on), 2) the bug report dimension (e.g., the component in which the bug was found) 3) the bug fix dimension (e.g., the amount of time it took to perform the initial fix) and 4) the team dimension (e.g., the experience of the bug fixer). Our case study on the Eclipse Platform 3.0 project shows that the comment and description text, the time it took to fix the bug, and the component the bug was found in are the most important factors in determining whether a bug will be re-opened. Based on these dimensions we create decision trees that predict whether a bug will be re-opened after its closure. Using a combination of our dimensions, we can build explainable prediction models that can achieve 62.9% precision and 84.5% recall when predicting whether a bug will be re-opened.

Understanding the impact of code and process metrics on post-release defects: a case study on the Eclipse project

Research studying the quality of software applications continues to grow rapidly with researchers building regression models that combine a large number of metrics. However, these models are hard to deploy in practice due to the cost associated with collecting all the needed metrics, the complexity of the models and the black box nature of the models. For example, techniques such as PCA merge a large number of metrics into composite metrics that are no longer easy to explain. In this paper, we use a statistical approach recently proposed by Cataldo et al. to create explainable regression models. A case study on the Eclipse open source project shows that only 4 out of the 34 code and process metrics impacts the likelihood of finding a post-release defect. In addition, our approach is able to quantify the impact of these metrics on the likelihood of finding post-release defects. Finally, we demonstrate that our simple models achieve comparable performance over more complex PCA-based models while providing practitioners with intuitive explanations for its predictions.

An empirical study on inconsistent changes to code clones at the release level

To study the impact of code clones on software quality, researchers typically carry out their studies based on fine-grained analysis of inconsistent changes at the revision level. As a result, they capture much of the chaotic and experimental nature inherent in any on-going software development process. Analyzing highly fluctuating and short-lived clones is likely to exaggerate the ill effects of inconsistent changes on the quality of the released software product, as perceived by the end user. To gain a broader perspective, we perform an empirical study on the effect of inconsistent changes on software quality at the release level. Based on a case study on three open source software systems, we observe that only 1.02%-4.00% of all clone genealogies introduce software defects at the release level, as opposed to the substantially higher percentages reported by previous studies at the revision level. Our findings suggest that clones do not have a significant impact on the post-release quality of the studied systems, and that the developers are able to effectively manage the evolution of cloned code.

Should I contribute to this discussion

Development mailing lists play a central role in facilitating communication in open source projects. Since these lists frequently host design and project discussions, knowledgeable contribution to these discussion threads is essential to avoid mis-communication that might slow-down the progress of a project. However, given the sheer volume of emails on these lists, it is easy to miss important discussions. To find out how developers are able to deal with mailing list discussions, we study the main factors that encourage developers to contribute to the development mailing lists. We develop personalized models to automatically identify discussion threads that a developer would contribute to based on his previous contribution behavior. Case studies on development mailing lists of three open source projects (Apache, PostgreSQL and Python) show that the average accuracy of our models is 89–85% and that the models vary significantly between different developers.

On the relationship between comment update practices and Software Bugs

When changing source code, developers sometimes update the associated comments of the code (a consistent update), while at other times they do not (an inconsistent update). Similarly, developers sometimes only update a comment without its associated code (an inconsistent update). The relationship of such comment update practices and software bugs has never been explored empirically. While some (in)consistent updates might be harmless, software engineering folklore warns of the risks of inconsistent updates between code and comments, because these updates are likely to lead to out-of-date comments, which in turn might mislead developers and cause the introduction of bugs in the future. In this paper, we study comment update practices in three large open-source systems written in C (FreeBSD and PostgreSQL) and Java (Eclipse). We find that these practices can better explain and predict future bugs than other indicators like the number of prior bugs or changes. Our findings suggest that inconsistent changes are not necessarily correlated with more bugs. Instead, a change in which a function and its comment are suddenly updated inconsistently, whereas they are usually updated consistently (or vice versa), is risky (high probability of introducing a bug) and should be reviewed carefully by practitioners.

GOSSIPY: A distributed localization system for Internet of Things using RFID technology

The popularity of smart objects in our daily life fosters a new generation of applications under the umbrella of the Internet of Things (IoT). Such applications are built on a distributed network of heterogeneous context-aware devices, where localization is a key issue. The localization problem is further magnified by IoT challenges such as scalability, mobility and the heterogeneity of objects. In existing localization systems using RFID technology, there is a lack of systems that localize mobile tags using heterogeneous mobile readers in a distributed manner. In this paper, we propose the GOSSIPY system for localizing mobile RFID tags using a group of ad hoc heterogeneous mobile RFID readers. The system depends on cooperation of mobile readers through time-constrained interleaving processes. Readers in a neighborhood share interrogation information, estimate tag locations accordingly and employ both proactive and reactive protocols to ensure timely dissemination of location information. We evaluate the proposed system and present its performance through extensive simulation experiments using ns-3.

RobP2P: A Robust Architecture for Resource Sharing in Mobile Peer-to-Peer Networks

Peer-to-peer (P2P) systems are constructed to provide resource sharing among interested participants (peers) in a distributed and self-organized fashion. The way P2P networks are formed is critical to the overall system performance due to communications and network maintenance overhead. Mobile environments pose additional challenges on P2P networks due to heterogeneity of nodes, inherent limited resources, dynamic context and wireless network characteristics. This paper presents RobP2P, a robust architecture to construct mobile P2P networks and efficiently maintain the network state. RobP2P introduces a novel super-peer selection protocol based on an aggregate utility function that takes into account peers’ capability and context. It also presents an agile scheme through which super-peers can delegate their responsibilities to more powerful and stable joining or existing peers. Our simulation results show that the RobP2P is efficient, less prone to failure, and generates lower overhead traffic, while reliably maintaining the consistency of network state . c

Using smart vehicles for localizing isolated Things

Elementary to the success of the Internet of Things (IoT) is the capability to accurately and efficiently localize its network components, information, and processes. In this paper, we focus on enabling localization of Things that have limited capabilities deployed in isolated areas. Specifically, we explore the scenario where the deployment or the utilization of dedicated anchor nodes becomes costly or practically unfeasible, and where the dependence on multi-hop localization techniques becomes inevitable. We further advocate the use of emerging IoT components such as smart vehicles, capable of self-localization and short-range communication. The proposed scheme thus illustrates the feasibility of a multi-hop wireless localization scheme dependent on mobile anchors (reference points). A key advantage of the proposed scheme is overcoming collinear trajectory (flip-ambiguity) problem, which arises whenever the smart vehicle moves in a straight trajectory. A Kalman Filter (KF) is used to decrease the location error introduced from the multi-hopping during the localization process. Through simulation, we show that the use of our localization scheme with KF reduces errors by 31% compared to localization using anchors from a single direction and 16% compared to a weighted means approach. Moreover, our scheme with KF consistently outperforms the typical range-based DV-Distance scheme with fixed anchors.

Does multi-hop communication enhance localization accuracy?

Estimating the location of sensor nodes in wireless sensor networks is a fundamental problem, as sensor node locations play a critical role in a variety of applications. In many cases the area covered is very large making it impossible to localize all sensor nodes using single-hop localization techniques. A solution to this problem is to use a multi-hop localization technique to estimate sensor node positions. Multi-hop localization techniques are classified into two main categories: range-based and range-free. Despite the numerous existing localization techniques, the fundamental behavior of multi-hop localization is yet to be fully examined. The aim of this paper is to study the effect of errors in a multi-hop localization environment and how this impacts localization accuracy. There has been a general belief that a fewer number of hops results in higher accuracy. Through different experiments on two generic localization techniques representing both categories of localization schemes, we show that such belief is not true in all cases, as in dense environments often using shorter hops gives better accuracy.