Development Effort Estimation Research Articles

Estimating the size of E-Learning System using Learning Object Points Method

Background/Objectives: Software size estimation is the key factor to determine the planning activities of software development process. Size is the base factor to determine effort, duration, schedule, cost and others that affect the development process. E-Learning system is also a software system support for Computer and internet based teaching and learning process. Development of E-Learning system is under crises because of improper estimates that lead incompleteness, loss and delay, it affects customer satisfaction. To overcome the problem, a research made on the sizing techniques used in industry and the inabilities are identified. Methods/Statistical Analysis: Based on the analysis of all industry oriented size estimation techniques, this research introduces a new sizing technique called Learning Object Point method (LOP). Learning Object Points method is quantifying the size and complexity of an E-Learning system in terms of learning objects and functionalities. Sizing is independent of computer languages, development methodology and technology behind the development. LOP can be estimated early stage of software development process. It is prepared based on the user perspective so users of the E-Learning system have a better understanding of what LOP are measuring. Findings: The performance analysis of Learning Object Point’s method was conducted over Function point Analysis by using different projects developed in the industry. Size and duration calculated using FPA produced wrong results. So the project management activities like planning, scheduling and costing produced imprecise outcomes but LOP produced more close to actual results so it supports project management activities effectively. Applications/Improvements: LOP can be used to size E-Learning applications accurately. Sizing is important component in determining productivity. It is easily understood by the non-technical user. This helps communicate sizing information to a user or customer. Conversion to LOC is similar to FP to LOC conversion. It also supports to estimate any kind software application other than E-Learning system also. Estimate development effort and Cost benefit analysis using LOP. To Derive Business Decisions.

Source code size prediction using use case metrics: an empirical comparison with use case points

Software source code size, in terms of source lines of code (SLOC), is an important parameter of many parametric software development effort estimation methods. In this paper, we investigate empirically the early prediction of SLOC for object-oriented software using use case metrics. We used different modeling techniques to build the prediction models. We used the univariate logistic regression and the simple linear regression methods to evaluate the individual effect of each use case metric on SLOC, and the multivariate logistic regression and the multiple linear regression methods to explore the combined effect of the use case metrics on SLOC. We also used in the study different machine learning methods (k-NN, naive Bayes, C4.5, random forest, and multilayer perceptron neural network). The prediction models were evaluated using the receiver operating characteristic analysis, particularly the area under the curve measure, and leave-one-out cross validation. An empirical study, using data collected from five open source Java projects, is reported in the paper. The use case metrics have been compared to the well-known use case points method. Results provide evidence that the use case metrics-based approach gives a more accurate prediction of SLOC than the use case points-based approach.

Functional size approximation based on use-case names

Context: Functional size measures, such as IFPUG Function Points or COSMIC, are widely used to support software development effort estimation. Unfortunately, applying the COSMIC or IFPUG Function Point Analysis methods at early stages of software development is difficult or even impossible because available functional requirements are imprecise. Moreover, the resources that could be allocated to perform such measurement are usually limited. Therefore, it is worth investigating the possibility of automating the approximation of IFPUG Function Points or COSMIC early in software projects.Objective: Given a UML use-case diagram or a list of use-case names, approximate COSMIC and IFPUG FPA functional size in an automatic way.Method: We propose a two-step process of approximating the functional size of applications based on use-case goals. In the first step, we process the names of use cases, expressed in a natural language and assign each of their goals into one of thirteen categories. In the second step, we employ information about categories of use-case goals and historical data to construct prediction models and use them to approximate the size in COSMIC and Function Points. We compare the accuracy of the proposed methods to the average use-case approximation (AUC), which is their most intuitive counterpart, and the automatic method proposed by Hussain, Kosseim and Ormandjieva (HKO).Results: The prediction accuracy of the two proposed approximation methods was evaluated using a cross-validation procedure on a data set of 26 software development projects. For both methods, the prediction error was low compared to AUC and HKO.Conclusion: Developers who document functional requirements in a form of use cases might use the proposed methods to obtain an early approximation of the application size as soon as use-case goals are identified. The proposed methods are automatic and can be considered as a replacement for AUC.

Improved estimation of software development effort using Classical and Fuzzy Analogy ensembles

Delivering an accurate estimate of software development effort plays a decisive role in successful management of a software project. Therefore, several effort estimation techniques have been proposed including analogy based techniques. However, despite the large number of proposed techniques, none has outperformed the others in all circumstances and previous studies have recommended generating estimation from ensembles of various single techniques rather than using only one solo technique. Hence, this paper proposes two types of homogeneous ensembles based on single Classical Analogy or single Fuzzy Analogy for the first time. To evaluate this proposal, we conducted an empirical study with 100/60 variants of Classical/Fuzzy Analogy techniques respectively. These variants were assessed using standardized accuracy and effect size criteria over seven datasets. Thereafter, these variants were clustered using the Scott-Knott statistical test and ranked using four unbiased errors measures. Moreover, three linear combiners were used to combine the single estimates. The results show that there is no best single Classical/Fuzzy Analogy technique across all datasets, and the constructed ensembles (Classical/Fuzzy Analogy ensembles) are often ranked first and their performances are, in general, higher than the single techniques. Furthermore, Fuzzy Analogy ensembles achieve better performance than Classical Analogy ensembles and there is no best Classical/Fuzzy ensemble across all datasets and no evidence concerning the best combiner.

Software Development Effort Estimation based-on multiple classifier system and Lines of Code

The development effort estimation is one of the most difficult problems in software project management. It is one of the most critical aspects in the early stages of the software project. Several software development effort estimation models have been proposed, however, these models are not able to obtain more than a 25 percent of accuracy, neither provide an understandable model for experts in the application area. Therefore, in this paper, we present EEpred, an explanatory model to estimate the development effort based on data of known software projects. It is a serial multiple classifier system based-on several decision trees. The model performance was evaluated by an internal validation procedure, analyzing their robustness and predictive performance. This procedure demonstrates that EEpred is able to estimate the software development effort with a 71 percent of precision. The main advantage of EEpred, regarding to other algorithms, is its ability to translate the process into a collection of simple decision rules, providing more easily interpretable knowledge that can help software engineer to improve decision-making on development planning.

Analyzing the Effect of Variables in the Software Development Effort Estimation

Due to the variability of variables, the estimation of effort in software development is considered as a very difficult task. Maybe due to small databases, uncertain and very subjective information. For these reason, in this paper, we introduce a study of the effect of variables in the software development effort estimation process. The estimation employing lines of codes, function points and engineering task, were taken as reference. With the use of datamining and machine learning technics, were demonstrated that the effort estimation using engineering task is more accurate. And, by the other hand, was established the influence of each variable, in the software development effort estimation process.

Systematic literature review of ensemble effort estimation

The need to overcome the weaknesses of single estimation techniques for prediction tasks has given rise to ensemble methods in software development effort estimation (SDEE). An ensemble effort estimation (EEE) technique combines several of the single/classical models found in the SDEE literature. However, to the best of our knowledge, no systematic review has yet been performed with a focus on the use of EEE techniques in SDEE. The purpose of this review is to analyze EEE techniques from six viewpoints: single models used to construct ensembles, ensemble estimation accuracy, rules used to combine single estimates, accuracy comparison of EEE techniques with single models, accuracy comparison between EEE techniques and methodologies used to construct ensemble methods. We performed a systematic review of EEE studies published between 2000 and 2016, and we selected 24 of them to address the questions raised in this review. We found that EEE techniques may be separated into two types: homogeneous and heterogeneous, and that the machine learning single models are the most frequently employed in constructing EEE techniques. We also found that EEE techniques usually yield acceptable estimation accuracy, and in fact are more accurate than single models.

Missing data techniques in analogy-based software development effort estimation

Missing Data (MD) is a widespread problem that can affect the ability to use data to construct effective software development effort prediction systems. This paper investigates the use of missing data (MD) techniques with two analogy-based software development effort estimation techniques: Classical Analogy and Fuzzy Analogy. More specifically, we analyze the predictive performance of these two analogy-based techniques when using toleration, deletion or k-nearest neighbors (KNN) imputation techniques. A total of 1512 experiments were conducted involving seven data sets, three MD techniques (toleration, deletion and KNN imputation), three missingness mechanisms (MCAR: missing completely at random, MAR: missing at random, NIM: non-ignorable missing), and MD percentages from 10 percent to 90 percent. The results suggest that Fuzzy Analogy generates more accurate estimates in terms of the Standardized Accuracy measure (SA) than Classical Analogy regardless of the MD technique, the data set used, the missingness mechanism or the MD percentage. Moreover, this study found that the use of KNN imputation, rather than toleration or deletion, may improve the prediction accuracy of both analogy-based techniques. However, toleration, deletion and KNN imputation are affected by the missingness mechanism and the MD percentage, both of which have a strong negative impact upon effort prediction accuracy.

Unit effects in software project effort estimation: Work-hours gives lower effort estimates than workdays

Software development effort estimates are typically expert judgment-based and too low to reflect the actual use of effort. Our goal is to understand how the choice of effort unit affects expert judgement-based effort estimates, and to use this knowledge to increase the realism of effort estimates. We conducted two experiments where the software professionals were randomly instructed to estimate the effort of the same projects in work-hours or in workdays. In both experiment, the software professionals estimating in work-hours had much lower estimates (on average 33%–59% lower) than those estimating in workdays. We argue that the unitosity effect—i.e., that we tend to infer information about the quantity from the choice of unit—is the main explanation for the large difference in effort estimates. A practical implication of the unit effect is that, in contexts where there is a tendency toward effort under estimation, the instruction to estimate in higher granularity effort units, such as workdays instead of work-hours, is likely to lead to more realistic effort estimates.

Workflow Development Effort Estimation as Applied to Web Human Resource Management

Over the past decade most of engineers, researchers, institutions, standard organizations and businessmen had been faced with challenges on how to represent productivity functions for effort estimation in information system workflow development. Despite the fact that workflows are everywhere, only few reports about its development effort are available. Accurate workflow sizing is a very difficult task at conceptual state. This paper proposes the proximity scoring measurement method to determine workflow size and to estimate workflow development effort with its knowledge retention effort. The approach is applied to the web publishing industry as a human resources case study. The approach of this paper is scalable and easy to apply to evaluate Web human resource workflow development effort. The implication of this work is that workflows can be estimated more precisely, helping to estimate the benefit of workflow reuse.

Bridging the semantic gap for software effort estimation by hierarchical feature selection techniques

Software project management is one of the significant activates in the software development process. Software Development Effort Estimation (SDEE) is a challenging task in the software project management. SDEE is an old activity in computer industry from 1940s and has been reviewed several times. A SDEE model is appropriate if it provides the accuracy and confidence simultaneously before software project contract. Due to the uncertain nature of development estimates and in order to increase the accuracy, researchers recently have focused on machine learning techniques. Choosing the most effective features to achieve higher accuracy in machine learning is crucial. In this paper, for narrowing the semantic gap in SDEE, a hierarchical method of filter and wrapper Feature Selection (FS) techniques and a fused measurement criteria are developed in a two-phase approach. In the first phase, two stage filter FS methods provide start sets for wrapper FS techniques. In the second phase, a fused criterion is proposed for measuring accuracy in wrapper FS techniques. Experimental results show the validity and efficiency of the proposed approach for SDEE over a variety of standard datasets.

Improving Efficiency of Fuzzy Models for Effort Estimation by Cascading & Clustering Techniques

The main challenge in software industry is the process of estimating the cost required for the development or maintenance of a project. Various models have been proposed for constructing a relationship between size of software and its development effort. Various algorithmic cost estimation models exists with their own pros and cons for estimation. Now a days, attention has turned towards Machine learning techniques as few of the problems associated with previous models are being addressed by the soft computing techniques. But, the need for accurate effort estimation in software project management is still a challenge. The literature shows the usage of Fuzzy Logic Controller for Software Effort Estimation, but the computational time is very high as the rulebase is large. The main aim is to reduce the rulebase and improve the efficiency by cascading of Fuzzy Logic Controllers. A case study on NASA 93 dataset is taken for this purpose. The Proposed work is carried out by cascading the Fuzzy Logic Controllers in a stage of two and six for Software Effort Estimation. By increasing the cascading of Fuzzy Logic Controllers, the efficiency has been improved with the minimized size in rulebase. The limitation to this process is to find out the correct number of cascaded Fuzzy Logic Controllers. To overcome this a Fuzzy Model using Subtractive Clustering has been proposed. The rulebase of the models developed by using Subtractive Clustering is further reduced. Considering the rule minimization and the various criteria for assessment, Fuzzy Models developed using Subtractive Clustering provides better software development effort estimates.

Web Effort Estimation: Function Point Analysis vs. COSMIC

Context: software development effort estimation is a crucial management task that critically depends on the adopted size measure. Several Functional Size Measurement (FSM) methods have been proposed. COSMIC is considered a 2nd generation FSM method, to differentiate it from Function Point Analysis (FPA) and its variants, considered as 1st generation ones. In the context of Web applications, few investigations have been performed to compare the effectiveness of the two generations. Software companies could benefit from this analysis to evaluate if it is worth to migrate from a 1st generation method to a 2nd one.Objective: the main goal of the paper is to empirically investigate if COSMIC is more effective than FPA for Web effort estimation. Since software companies using FPA cannot build an estimation model based on COSMIC as long as they do not have enough COSMIC data, the second goal of the paper is to investigate if conversion equations can be exploited to support the migration from FPA to COSMIC.Method: two empirical studies have been carried out by employing an industrial data set. The first one compared the effort prediction accuracy obtained with Function Points (FPs) and COSMIC, using two estimation techniques (Simple Linear Regression and Case-Based Reasoning). The second study assessed the effectiveness of a two-step strategy that first exploits a conversion equation to transform historical FPs data into COSMIC, and then builds a new prediction model based on those estimated COSMIC sizes.Results: the first study revealed that, on our data set, COSMIC was significantly more accurate than FPs in estimating the development effort. The second study revealed that the effectiveness of the analyzed two-step process critically depends on the employed conversion equation.Conclusion: for Web effort estimation COSMIC can be significantly more effective than FPA. Nevertheless, additional research must be conducted to identify suitable conversion equations so that the two-step strategy can be effectively employed for a smooth migration from FPA to COSMIC.

A differential evolution-based model to estimate the software services development effort

Accurate estimation of software service development effort is a great challenge both in industry and for academia. The concept of effort is an important and effective parameter in process development and software service management. The reliable estimation of effort helps the project managers to allocate the resources better and manage cost and time so that the project will be finished in the determined time and budget. One of the most popular effort estimation methods is analogy-based estimation ABE to compare a service with similar historical cases. Unfortunately, ABE is not capable of generating accurate results unless determining weights for service features. Therefore, this paper aims to make an efficient and reliable model through combining ABE method and differential evolution algorithm to estimate the software services development effort. In fact, the differential evolution algorithm was utilized for weighing features in the similarity function of the ABE method. This weighing process could help determining the importance level of the various service features and extracting the best similar historical case. The proposed hybrid model has been evaluated on two real datasets and two artificial datasets. The obtained results were compared with common effort estimation methods. This comparison showed more accuracy, faster convergence, and lower cost of the proposed model. Copyright © 2015 John Wiley & Sons, Ltd.

Neural network models for software development effort estimation: a comparative study

Software development effort estimation (SDEE) is one of the main tasks in software project management. It is crucial for a project manager to efficiently predict the effort or cost of a software project in a bidding process, since overestimation will lead to bidding loss and underestimation will cause the company to lose money. Several SDEE models exist; machine learning models, especially neural network models, are among the most prominent in the field. In this study, four different neural network models: Multilayer Perceptron, General Regression Neural Network, Radial Basis Function Neural Network, and Cascade Correlation Neural Network are compared with each other based on: (1) predictive accuracy centered on the Mean Absolute Error criterion, (2) whether such a model tends to overestimate or underestimate, and (3) how each model classifies the importance of its inputs. Industrial datasets from the International Software Benchmarking Standards Group (ISBSG) are used to train and validate the four models. The main ISBSG dataset was filtered and then divided into five datasets based on the productivity value of each project. Results show that the four models tend to overestimate in 80percent of the datasets, and the significance of the model inputs varies based on the selected model. Furthermore, the Cascade Correlation Neural Network outperforms the other three models in the majority of the datasets constructed on the Mean Absolute Residual criterion.

The Application of Meta-Heuristic Algorithms to Improve the Performance of Software Development Effort Estimation Models

One of the major activities in effective and efficient production of software projects is the precise estimation of software development effort. Estimation of the effort in primary steps of software development is one of the most important challenges in managing software projects. Some reasons for these challenges such as: discordant software projects, the complexity of the manufacturing process, special role of human and high level of obscure and unusual features of software projects can be noted. Predicting the necessary efforts to develop software using meta-heuristic optimization algorithms has made significant progressions in this field. These algorithms have the potent to be used in estimation of the effort of the software. The necessity to increase estimation precision urged the authors to survey the efficiency of some meta-heuristic optimization algorithms and their effects on the software projects. To do so, in this paper, they investigated the effect of combining various optimization algorithms such as genetic algorithm, particle swarm optimization algorithm and ant colony algorithm on different models such as COCOMO, estimation based on analogy, machine learning methods and standard estimation models. These models have employed various data sets to evaluate the results such as COCOMO, Desharnais, NASA, Kemerer, CF, DPS, ISBSG and Koten & Gary. The results of this survey can be used by researchers as a primary reference.

Model to estimate the software development effort based on in‐depth analysis of project attributes

Over the past years, numerous models have been proposed to estimate the development effort in the early stages of a software project. The existing models have mostly relied on soft computing techniques and weighting methods. Although they have reduced the complexity and vagueness of software project attributes, attempts are ongoing to develop more accurate and reliable estimation models. This paper is concentrated on selective classification of software projects based on underlying attributes to localise the development effort estimation process in a widely used model called analogy-based estimation (ABE). The proposed model is a combination of ABE, selective classification and a weighting system in which the attributes of different software projects are assigned different weights. In fact, the process of attribute weighting is customised based on the nature of project being estimated. A real data set was utilised to evaluate the performance of the proposed model. A comparison between the estimates achieved by the proposed model and those obtained from other well-known effort estimation models showed that the proposed model substantially improves the performance metrics. Along with the improvement of accuracy, the proposed model is able to be used in an extensive domain of software projects.

Numerical anchors and their strong effects on software development effort estimates

The anchoring effect may be described as the tendency for an initial piece of information to influence people's subsequent judgement, even when the information is irrelevant. Previous studies suggest that anchoring is an important source of inaccurate software development effort estimates. This article examines how the preciseness and credibility of anchoring information affects effort estimates. Our hypotheses were that anchors with lower numerical precision and anchor sources with lower credibility would have less impact on effort estimates. The results from three software project effort estimation experiments, with 381 software professionals, support previous findings about the relevance of anchoring effects to software effort estimation. However, we found no decrease in the anchoring effect with decreasing anchor precision or source credibility. This suggests that even implausible anchors from low-credibility sources can lead to anchoring effects, and that all kinds of misleading information potentially acting as estimation anchors in project estimation contexts should be avoided.

Early effort estimation in web application development

Project planning in software industry represents one of the most complex tasks, especially when there is a need to estimate the time, cost and effort needed for development of software projects. In the field of development effort estimation for classical software projects a number of methods have been developed, tested and successfully implemented. Web projects are, by their nature, different than classical software projects, and there is a lack of methods and models that provides a high degree of confidence in development effort estimation. This paper analyzes the possibility of using a combination of functional size and conceptual models for the purpose of web application development effort estimation. Measurement of functional size can be effectively applied to the conceptual models of the data-driven web applications because of the existence of extensive count of data movements. For the purpose of this study 19 web applications with their conceptual models were employed. An effort model was built using simple linear regression analysis. Upon construction, evaluation and validation of the effort model prediction accuracy elements, R2, MMRE, and Pred(l), showed promising results for web projects used in the model construction and validation process.

Optimizing Software Effort Estimation Models Using Firefly Algorithm

Software development effort estimation is considered a fundamental task for software development life cycle as well as for managing project cost, time and quality. Therefore, accurate estimation is a substantial factor in projects success and reducing the risks. In recent years, software effort estimation has received a considerable amount of attention from researchers and became a challenge for software industry. In the last two decades, many researchers and practitioners proposed statistical and machine learning-based models for software effort estimation. In this work, Firefly Algorithm is proposed as a metaheuristic optimization method for optimizing the parameters of three COCOMO-based models. These models include the basic COCOMO model and other two models proposed in the literature as extensions of the basic COCOMO model. The developed estimation models are evaluated using different evaluation metrics. Experimental results show high accuracy and significant error minimization of Firefly Algorithm over other metaheuristic optimization algorithms including Genetic Algorithms and Particle Swarm Optimization.