Abdulaziz Alkhalid

Software refactoring at the package level using clustering techniques

Enhancing, modifying or adapting the software to new requirements increases the internal software complexity. Software with high level of internal complexity is difficult to maintain. Software refactoring reduces software complexity and hence decreases the maintenance effort. However, software refactoring becomes quite challenging task as the software evolves. The authors use clustering as a pattern recognition technique to assist in software refactoring activities at the package level. The approach presents a computer aided support for identifying ill-structured packages and provides suggestions for software designer to balance between intra-package cohesion and inter-package coupling. A comparative study is conducted applying three different clustering techniques on different software systems. In addition, the application of refactoring at the package level using an adaptive k-nearest neighbour (A-KNN) algorithm is introduced. The authors compared A-KNN technique with the other clustering techniques (viz. single linkage algorithm, complete linkage algorithm and weighted pair-group method using arithmetic averages). The new technique shows competitive performance with lower computational complexity.

On algorithm for building of optimal α-decision trees

The paper describes an algorithm that constructs approximate decision trees (α-decision trees), which are optimal relatively to one of the following complexity measures: depth, total path length or number of nodes. The algorithm uses dynamic programming and extends methods described in [4] to constructing approximate decision trees. Adjustable approximation rate allows controlling algorithm complexity. The algorithm is applied to build optimal α-decision trees for two data sets from UCI Machine Learning Repository [1].

Extensions of Dynamic Programming as a New Tool for Decision Tree Optimization

The chapter is devoted to the consideration of two types of decision trees for a given decision table: α-decision trees (the parameter α controls the accuracy of tree) and decision trees (which allow arbitrary level of accuracy). We study possibilities of sequential optimization of α-decision trees relative to different cost functions such as depth, average depth, and number of nodes. For decision trees, we analyze relationships between depth and number of misclassifications. We also discuss results of computer experiments with some datasets from UCI ML Repository.

Software refactoring at the function level using new Adaptive K-Nearest Neighbor algorithm

Improving the quality of software is a vital target of software engineering. Constantly evolving requirements force software developers to enhance, modify, or adapt software. Thus, increasing internal complexity, maintenance effort, and ultimately cost. In trying to balance between the needs to change software, maintain high quality, and keep the maintenance effort and cost low, refactoring comes up as a solution. Refactoring aims to improve a number of quality factors, among which is understandability. Enhancing understandability of ill-structured software decreases the maintenance effort and cost. To improve understandability, designers need to maximize cohesion and minimize coupling, which becomes more difficult to achieve as software evolves and internal complexity increases. In this paper, we propose a new Adaptive K-Nearest Neighbor (A-KNN) algorithm to perform clustering with different attribute weights. The technique is used to assist software developers in refactoring at the function/method level. This is achieved by identifying ill-structured software entities and providing suggestions to improve cohesion of such entities. We also compare the proposed technique with three function-level clustering techniques Single Linkage algorithm (SLINK), Complete Linkage algorithm (CLINK) and Weighted Pair-Group Method using Arithmetic averages (WPGMA). A-KNN showed competitive performance with the other three algorithms and required less computational complexity.

Optimization and analysis of decision trees and rules: dynamic programming approach

Abstract This paper is devoted to the consideration of software system Dagger created in KAUST. This system is based on extensions of dynamic programming. It allows sequential optimization of decision trees and rules relative to different cost functions, derivation of relationships between two cost functions (in particular, between number of misclassifications and depth of decision trees), and between cost and uncertainty of decision trees. We describe features of Dagger and consider examples of this system’s work on decision tables from UCI Machine Learning Repository. We also use Dagger to compare 16 different greedy algorithms for decision tree construction.

A tool for study of optimal decision trees

The paper describes a tool which allows us for relatively small decision tables to make consecutive optimization of decision trees relative to various complexity measures such as number of nodes, average depth, and depth, and to find parameters and the number of optimal decision trees.

Software Architecture Decomposition Using Clustering Techniques

While applying clustering techniques to software system decomposition, the software designer faces two practical issues: (1) determination of the number of clusters that will be mapped to software modules and (2) determination of a specific cluster or software module for some highly coupled components. This paper presents an approach for software architecture decomposition with an emphasis on finding solutions to those two issues. The approach uses fuzzy c-means clustering together with three hierarchical agglomerative clustering methods and the adaptive K-nearest neighbor algorithm. We applied the approach to real industrial software systems. The results show that our approach provides objective and insightful information to the software designer in dealing with those two issues.

A lightweight defence against the Packet in Packet attack in ZigBee networks

ZigBee is a standard for low-power, low-rate wireless communication. It is modeled on the physical layer and medium access control defined in IEEE 802.15.4. In this paper, we study an attack on modern radios called the “Packet in Packet” (PIP) attack. We replicate the attack in ZigBee devices and discuss possible defenses against the attack. We implement a solution to thwart the PIP attack in TinyOS and show through extensive experiments that the solution defends against the attack, while imposing little additional overhead.

Comparison of greedy algorithms for α-decision tree construction

A comparison among different heuristics that are used by greedy algorithms which constructs approximate decision trees (α-decision trees) is presented. The comparison is conducted using decision tables based on 24 data sets from UCI Machine Learning Repository [2]. Complexity of decision trees is estimated relative to several cost functions: depth, average depth, number of nodes, number of nonterminal nodes, and number of terminal nodes. Costs of trees built by greedy algorithms are compared with minimum costs calculated by an algorithm based on dynamic programming. The results of experiments assign to each cost function a set of potentially good heuristics that minimize it.

Software architecture decomposition using adaptive K-nearest neighbor algorithm

Software architecture decomposition plays an important role in software design cascading effect on various development phases. Software designer decomposes software based on his/her experience. Though it may work well for some, in reality many systems failed to meet the requirements as a result of poor design. Software architecture decomposition using clustering techniques has been investigated in software engineering research. This paper presents an enhanced approach for software architecture decomposition. We used two hierarchical agglomerative clustering methods and adaptive K-nearest neighbor algorithm in this enhanced approach and applied it on two industrial software systems. Results show that the approach provides objective and insightful information for software designer.