Maen Hammad

Assigning change requests to software developers

The paper presents an approach to recommend a ranked list of expert developers to assist in the implementation of software change requests (e.g., bug reports and feature requests). An Information Retrieval (IR)‐based concept location technique is first used to locate source code entities, e.g., files and classes, relevant to a given textual description of a change request. The previous commits from version control repositories of these entities are then mined for expert developers. The role of the IR method in selectively reducing the mining space is different from previous approaches that textually index past change requests and/or commits. The approach is evaluated on change requests from three open‐source systems: ArgoUML, Eclipse, and KOffice, across a range of accuracy criteria. The results show that the overall accuracies of the correctly recommended developers are between 47 and 96% for bug reports, and between 43 and 60% for feature requests. Moreover, comparison results with two other recommendation alternatives show that the presented approach outperforms them with a substantial margin. Project leads or developers can use this approach in maintenance tasks immediately after the receipt of a change request in a free‐form text. Copyright

Automatically identifying changes that impact code-to-design traceability during evolution

An approach is presented that automatically determines if a given source code change impacts the design (i.e., UML class diagram) of the system. This allows code-to-design traceability to be consistently maintained as the source code evolves. The approach uses lightweight analysis and syntactic differencing of the source code changes to determine if the change alters the class diagram in the context of abstract design. The intent is to support both the simultaneous updating of design documents with code changes and bringing old design documents up to date with current code given the change history. An efficient tool was developed to support the approach and is applied to an open source system. The results are evaluated and compared against manual inspection by human experts. The tool performs better than (error prone) manual inspection. The developed approach and tool were used to empirically investigate and understand how changes to source code (i.e., commits) break code-to-design traceability during evolution and the benefits from such understanding. Commits are categorized as design impact or no impact. The commits of four open source projects over 3-year time durations are extracted and analyzed. The results of the study show that most of the code changes do not impact the design and these commits have a smaller number of changed files and changed less lines compared to commits with design impact. The results also show that most bug fixes do not impact design.

Automatically identifying changes that impact code-to-design traceability

An approach is presented that automatically determines if a given source code change impacts the design (i.e., UML class diagram) of the system. This allows code-to-design traceability to be consistently maintained as the source code evolves. The approach uses lightweight analysis and syntactic differencing of the source code changes to determine if the change alters the class diagram in the context of abstract design. The intent is to support both the simultaneous updating of design documents with code changes and bringing old design documents up to date with current code given the change history. An efficient tool was developed to support the approach and is applied to an open source system (i.e., HippoDraw). The results are evaluated and compared against manual inspection by human experts. The tool performs better than (error prone) manual inspection.

Using stereotypes to help characterize commits

Individual commits to a version control system are automatically characterized based on the stereotypes of added and deleted methods. The stereotype of each method is automatically reverse engineerd using a previously defined taxonomy. Method stereotypes reflect intrinsic atomic behavior of a method and its role in the class. The stereotypes of the added and deleted methods form a descriptors are then used to categorize commits, into types, based on the impact of the changes to a class (or classes). The goal is to gain a better understanding of the design changes to a system over its history and provide a means for documenting the commit.

Measuring Class Importance in the Context of Design Evolution

A measure of how a class is impacted during design evolution is presented. The history of design changes that involve a given class is the basis for the measure. Classes that are often impacted by design changes are branded as important to the design of the system. Identifying these important classes helps reveal what parts of the system are regularly evolved (e.g., specific features or cross-cutting concerns). The design importance of a class is measured as the number of commits that impact both the design and the class. This is also measured for sets of classes that collaborate to realize a feature or concept in the system. Collaborating classes are identified using itemset mining on commits that impact the design. A small study is presented on two open source projects to illustrate the approach.

A dynamic replication strategy based on categorization for Data Grid

Data Replication is copying the data from a certain location to another location. Replication is used in Data Grid to have two or more copies of the same data at different locations. In this paper, a Category-based dynamic replication strategy (CDRS) is proposed. The strategy takes into account that the replicas exist on a node belong to different categories. Each of these categories is given a value that determines its importance for the node. When the nodes storage is full, the node starts to store only the replicas that belong to the category with the highest value. The results of the simulations show that the new proposed strategy achieved better performance than Plain Caching and Fast Spread strategies in terms of total transit time and total bandwidth consumption.

An approach to automatically enforce object-oriented constraints

This paper presents an approach to automatically enforce object-oriented constraints during incremental C++ code changes. The approach is realised as a tool to keep track on code changes and to notify developers with violations of predefined OO constraints. The OO constraints under consideration are taken from object-oriented design metrics. The object-oriented metrics mainly cover class size, coupling between classes, number of subclasses and inheritance tree. The goal of this work is to help designers to monitor design during incremental code changes. Object-oriented design metrics are automatically extracted from source code. The extracted metrics are used by designers to define the constraints. The tool supports defining and managing these OO constraints. After a code change is committed, design changes are identified and predefined constraints are checked for possible violations. The evaluation of the tool shows that it helps in detecting violations of design constraints, and it saves time and efforts of developers.

Automatic Reverse Engineering of Classes’ Relationships

Classes are the core of object oriented systems. Any maintenance activity includes performing a code change to one or more classes. Any code change to one class may affect other classes in the project. So, developers need to be aware and fully understand the structure and the relationships between classes. This paper proposes a technique to automatically extract various types of class’s relationships from source code. The proposed technique extracts relationships among classes and measures their involvements in relationships. Fan-in and Fan-out metrics are used to give developers more comprehensive picture about the current status of coupling for each class.

An Index-Based Approach for Wireless Sensor Networks

Sensor nodes have significant power constraints (battery life). Thus, power-aware approaches must be employed to prolong the network lifetime. However, most of the literature considers only routing-based approaches to prolong it. In this paper, we propose an index-based approach that provides a new way for reducing the energy consumption. The idea behind this new proposed approach is having an index for each possible value for a sensed reading. The index length will have much less length than the reading if the possible values for the sensed reading are limited. In this case, sending the corresponding index for a reading instead of the reading itself will result in decreasing the size of the submitted packet and therefore reducing the consumed energy. The experimental results show that our approach reduces both the total energy consumption and total elapsed time in the case the number of the possible different values for each sensed reading is up to 32,768