Jarallah AlGhamdi

ADAPTIVE FUZZY LOGIC BASED FRAMEWORK FOR SOFTWARE DEVELOPMENT EFFORT PREDICTION

Abstract Algorithmic effort prediction models are limited by their inability to cope with uncertainties and imprecision present in software projects early in the development life cycle. In this paper, we present an adaptive fuzzy logic framework for software effort prediction. The training and adaptation algorithms implemented in the framework tolerates imprecision, explains prediction rationale through rules, incorporates experts knowledge, offers transparency in the prediction system, and could adapt to new environments as new data becomes available. Our validation experiment was carried out on artificial datasets as well as the COCOMO public database. We also present an experimental validation of the training procedure employed in the framework.

OOMeter: a software quality assurance tool

This paper gives an overview of OOMeter, a software metric tool that accepts Java and C# source code as well as UML models in XMI format.

Probabilistic size proxy for software effort prediction: A framework

Software effort prediction is an important and challenging activity that takes place during the early stages of software development, where costing is needed. Software size estimate is one of the most popular inputs for software effort prediction models. Accordingly, providing a size estimate with good accuracy early in the lifecycle is very important; it is equally challenging too. Estimates that are computed early in the development lifecycle, when it is needed the most, are typically associated with uncertainty. However, none of the prominent software effort prediction techniques or software size metrics addresses this issue satisfactorily. In this paper, we propose a framework for developing probabilistic size proxies for software effort prediction using information from conceptual UML models created early in the software development lifecycle. The framework accounts for uncertainty in software size and effort prediction by providing the estimate as a probability density function instead of a certain value. We conducted a case study using open source datasets and the results were encouraging.

A data-centric design for n-tier architecture

The increasing heterogeneity, complexity, and distributed nature of deployment architectures only serve to compound the problems faced by software solutions. With the advent of the Internet and web technologies, system designers have had to reevaluate the applicability of n-tier architectures, and assess which technologies are appropriate at each tier. In this paper we evaluate the design issues of n-tier architecture. We debate whether it is good to move code or data to communicate messages between applications. Based on the latest technology of J2EE and .NET framework, we recommend a data centric design of n-tier architecture. Based on our experience we also suggest a modified interactive software process model.

A tool for measuring inheritance coupling in object-oriented systems

Analyzing object-oriented systems in order to evaluate their quality gains its importance as the paradigm continues to increase in popularity. Consequently, several object-oriented metrics have been proposed to evaluate different aspects of these systems such as class coupling. In object-oriented design, three types of coupling may exist between classes: inheritance coupling, interaction coupling, and component coupling. This paper presents a tool for measuring inheritance coupling in object-oriented systems.

Towards measuring object-oriented class stability

Stable software, the capability of software to evolve while preserving its design, is an important software feature that software engineers strive for. Stable software tends to reduce maintenance cost and effort. Object-oriented (OO) classes form the basic components of the software systems; hence, stable OO classes may contribute to reducing the maintenance and effort cost. The authors identified factors that affect class stability and then used these factors to propose new class stability metric (CSM). Also, the authors theoretically and empirically validated CSM. The results show that the proposed CSM is negatively correlated with the maintenance effort.

Can Cohesion Predict Fault Density

Cohesion is an internal software attribute which depicts how well the components of a software module are connected. It is thought of as having effect on the quality of the software system. This paper presents the results of an empirical investigation of whether cohesion of object-oriented systems plays a role on software reliability. The paper presents a study of the correlation between cohesion measures and the number of defects in software systems, using seven open source projects.

A study on the uncertainty inherent in class cohesion measurements

Software metrics are essential for component certification and for the development of high quality software in general. Accordingly, research in the area of software metrics has been active and a wide range of metrics has been proposed. However, the variety of metrics proposed for measuring the same quality attribute suggests that there may be some sort of inconsistencies among the measurements computed using these metrics. In this paper, we report a case study considering class cohesion as a quality attribute of concern. We present the results of our empirical investigation to confirm that prominent object-oriented class cohesion metrics provide inconsistent measurements. We also present an analysis of the uncertainty that should be considered in these class cohesion measurements due to their inter-inconsistencies. Considering such uncertainty, we provide a framework for associating a probability distribution of error to the measurements computed by each metric; thus enabling the assessment of the degree of reliability of measurements of each metric when used to rank a set of classes with regard to their cohesion quality. The error probability distribution would be useful in practice where it is seldom feasible to use a large set of metrics and rather a single metric is used.

MULTITHREADED PARALLELISM WITH OPENMP

While multithreaded programming is an effective way to exploit concurrency, multithreaded programs are notoriously hard to program, debug and tune for performance. In this paper, we present OpenMP shared memory programming as a viable alternative and a much simpler way to write multithreaded programs. We show through empirical results obtained by running, on a single processor machine, a simple matrix multiplication program written in OpenMP C that the drop in performance compared with the single threaded version even on a uniprocessor machine may be negligible. However, this is well compensated for by the increased programmer productivity resulting from the ease of programming, debugging, tuning and the relative ease of OpenMP skill acquisition.

SPMDL: Software Product Metrics Definition Language

Software metrics are becoming more acceptable measures for software quality assessment. However, there is no standard form to represent metric definitions, which would be useful for metrics exchange and customization. In this article, we propose the Software Product Metrics Definition Language (SPMDL). We develop an XML-based description language to define software metrics in a precise and reusable form. Metric definitions in SPMDL are based on meta-models extracted from either source code or design artifacts, such as the Dagstuhl Middle Meta-model, with support for various abstraction levels. The language defines several flexible computation mechanisms, such as extended Object Constraint Language queries and predefined graph operations on the meta-model. SPMDL provides an unambiguous description of the metric definition; it is also easy to use and is extensible.