Effort Estimation Research Articles

Analysis of cost estimation using the web metrics and cost driver in the high performance of web developers

In recent years, many researchers and software industries have given significant attention to the estimation of software effort. Software effort estimation is a challenge that often appears in the project of making software. To address this issue, various software expansion cost estimations have been familiarized. A basic traditional method for cost estimation is the Constructive Cost Model II (COCOMO II Model), which generates huge gradations of substantiality. The proposed COCOMO II model employs cost drivers, measures and the streak of programmes to predict the energy and the growth period of a web rise. However, the model is still lacking in terms of accuracy in effort and development time estimation. In this study, we do investigate the influence of components and attributes to achieve new better accuracy improvement on the COCOMO II model. The NASA93 dataset is used to test the suggested methodology. The system has outperformed earlier investigations and arrangements capable of imperfect data input, and further advancements in the reliability of the estimated technique.

Brief review of classical Effort Estimation models for Software development projects

A critical synthesis on the most representative models for software development project effort estimation is provided. This work is a basis for a discussion about the methodological and practical challenges which entail the effort estimation field, specially in the mathematical/statistical modelling fundamentals, and its empirical verification in the software industry.

Reliable machine learning models for estimating effective software development efforts: A comparative analysis

Effort estimation in the software industry is recognized as one of the most critical activities for the success of the overall solution delivery in the software development process. Software Development Effort Estimation (SDEE) predicts the efforts to develop any software project in terms of persons-month or person-hours. Effort prediction in the early stages of the software development life cycle (SDLC) is always been a challenge. The primary objective of this paper is to analyse different machine learning models and to identify a stable and accurate estimation model for efficient effort estimation. The paper performs a comparative analysis, to analyze the performance of eight different machine learning models, with commonly used datasets in the domain of Software Development Effort Estimation, in terms of eight metrics. On performing experiments and comparing metrics, the analysis showed that the various machine learning estimation models outperformed some particular datasets, hence it can be concluded that machine learning boost-up the performance in the domain of SDEE. Moreover, to conclude, the paper also compared the models based upon the first three choices of models and identified Random Forest has comprehensive superiority and stability in terms of accuracy in estimation, followed by other models.

Much more than a prediction: Expert-based software effort estimation as a behavioral act

Much more than a prediction: Expert-based software effort estimation as a behavioral act

TRADITIONAL AND RECENT TECHNIQUES OF EFFORT ESTIMATION IN SOFTWARE ENGINEERING

In software engineering effort is used to represent measure of use of workforce. It is defined as totaltime that takes members of a software developing team to perform a given task. Software development effort estimating remains a complex problem, and one which continues to attract considerable research attention. The success or failure of projects depends on the accuracy of effort and schedule estimation.The aim of this paper is to present the most relevant methods and models for effort estimation used by software engineers.The primary conclusion is that no single technique is best for all condition because every method or model has an own significance or importance.

Toward a reclamation effort estimation procedure for open pit mines

Toward a reclamation effort estimation procedure for open pit mines

On the marketing effect of financial analysts: Evidence from investor bids in SEO auctions

This study investigates the marketing effect of financial analyst in seasoned equity offering (SEO) auctions and how this influences the price elasticity and sales of stocks. Analyzing detailed investor bids in China, we find that a greater marketing effort of financial analysts leads to increased investor demand, higher demand elasticities, and lower discounts in SEO auctions. These results are validated by utilizing estimated residual analyst reports, 2SLS estimation and alternative measures of analyst marketing effort. Further, we adopt a causal steps approach, confirming that a financial analyst increases investor demand by broadening the investor base and demand elasticity by reducing differences of opinion among investors. Our findings demonstrate that financial analysts play a marketing role in financial markets in addition to information gathering and monitoring. Our study provides novel evidence of an underlying mechanism driving the negative relationship between financial analysts and SEO discounts and offers practical insights into market regulation and monitoring.

Assessment of Inspiratory Effort in Spontaneously Breathing COVID-19 ARDS Patients Undergoing Helmet CPAP: A Comparison between Esophageal, Transdiaphragmatic and Central Venous Pressure Swing.

The clinical features of COVID-19 are highly variable. It has been speculated that the progression across COVID-19 may be triggered by excessive inspiratory drive activation. The aim of the present study was to assess whether the tidal swing in central venous pressure (ΔCVP) is a reliable estimate of inspiratory effort. Thirty critically ill patients with COVID-19 ARDS underwent a PEEP trial (0-5-10 cmH2O) during helmet CPAP. Esophageal (ΔPes) and transdiaphragmatic (ΔPdi) pressure swings were measured as indices of inspiratory effort. ΔCVP was assessed via a standard venous catheter. A low and a high inspiratory effort were defined as ΔPes ≤ 10 and >15 cmH2O, respectively. During the PEEP trial, no significant changes in ΔPes (11 [6-16] vs. 11 [7-15] vs. 12 [8-16] cmH2O, p = 0.652) and in ΔCVP (12 [7-17] vs. 11.5 [7-16] vs. 11.5 [8-15] cmH2O, p = 0.918) were detected. ΔCVP was significantly associated with ΔPes (marginal R2 0.87, p < 0.001). ΔCVP recognized both low (AUC-ROC curve 0.89 [0.84-0.96]) and high inspiratory efforts (AUC-ROC curve 0.98 [0.96-1]). ΔCVP is an easily available a reliable surrogate of ΔPes and can detect a low or a high inspiratory effort. This study provides a useful bedside tool to monitor the inspiratory effort of spontaneously breathing COVID-19 patients.

A METRICS -BASED MODEL FOR ESTIMATING THE MAINTENANCE EFFORT OF PYTHON SOFTWARE

Software project management includes a substantial area for estimating software maintenance effort. Estimation of software maintenance effort improves the overall performance and efficiency of software. The Constructive Cost Model (COCOMO) and other effort estimation models are mentioned in literature but are inappropriate for Python programming language. This research aimed to modify the Constructive Cost Model (COCOMO II) by considering a range of Python maintenance effort influencing factors to get estimations and incorporated size and complexity metrics to estimate maintenance effort. A within-subjects experimental design was adopted and an experiment questionnaire was administered to forty subjects aiming to rate the maintainability of twenty Python programs. Data collected from the experiment questionnaire was analyzed using descriptive statistics. Metric values were collected using a developed metric tool. The subject ratings on software maintainability were correlated with the developed model’s maintenance effort, a strong correlation of 0.610 was reported meaning that the model is valid.

Towards effective feature selection in estimating software effort using machine learning

AbstractSoftware effort estimation is a vital process in the software industry for successfully administering 5Ds of the software development life cycle (SDLC). The 5Ds stand for demand, development, direction, deployment, and designated cost of the software. Software development effort estimation (SDEE) is an effort prediction mechanism to calculate the effort for the development of the software product in order to minimize the challenges in the software field. Academics and practitioners are striving to identify which machine learning estimation technique yields more accurate results based on evaluation metrics, datasets, and other pertinent aspects. The feature selection techniques impact accuracy by selecting the main and relevant features in the dataset and eliminating the redundant and irrelevant features in the dataset. To achieve accurate estimations, the paper utilizes feature selection algorithms, along with various machine learning techniques, which predict the desired effort and the performance of the model has been measured in terms of prediction accuracy, value, relative error, and mean absolute error. The datasets China and Maxwell are trained with the relevant features by applying feature selection algorithms, and estimation techniques are applied to predict the effort. The performance is compared with the regression models and feature selection techniques utilized by many authors previously. The result of the proposed methodology significantly gives the best performance with the combination of feature selection and estimation models than all regression models when applied alone, to both datasets. From the results, it is perceptible that random forest is performing well with the feature selection techniques and obtains the highest prediction accuracy of 99.33% with the China and 89.47% with the Maxwell datasets.

An empirical evaluation of scrum training’s suitability for the model-driven development of knowledge-intensive software systems

A Product Configuration System (PCS) is a software system that facilitates the sales and production processes of defined customizable products. PCS are specific software developments in the sense that they are knowledge-intensive so that they require models to formalize the complex knowledge inherent to product configurations also leading to dependencies between software functionalities. Scrum is a widely used agile method, but its training has been the subject of little research. Model-driven development implicitly impacts the way development is conducted especially when adopting an agile method as Scrum. This paper, as exploratory research, evaluates Scrum training for PCS projects through a qualitative case study. The goal is to identify the elements that should be focused on within Scrum background training. This research first studies and assesses the training experiences at the case company. Then, it reports on respondents’ opinions about the strengths and challenges of applying Scrum in the mentioned context. The latter is based on multiple data sources: documentation, interviews, participant observations, and workshops. Issues in applicability lead to enhanced training support for learning how to (i) combine Scrum with the model-driven approach inherently required within PCS development, (ii) manage time and effort estimation on the basis of accurate artifacts and (iii) access key employees possessing domain or specific technical knowledge indispensable for pursuing the development.

Using baited remote underwater videos to survey freshwater turtles

AbstractNew and innovative techniques utilizing underwater cameras have the potential to track changes in turtle populations whilst being less invasive and time intensive than traditional trapping surveys. In this study, we trialled the use of Baited Remote Underwater Videos (BRUVs) in five upland streams to test if BRUVs could be used for abundance, size and sex estimates of freshwater turtles. We also compared BRUVs to cathedral traps and identified key considerations for future use of this method, such as whether the time of day influenced results. Our study successfully detected 83 turtles from 52 h of footage and identified all species known to occur in the study area. The deployment time did not significantly influence relative abundance. BRUVs also produced statistically similar catch per unit effort estimates to cathedral trapping techniques. No small turtles (i.e. juveniles) were detected, and difficulties with visibility, sex accuracy and carapace measurements are discussed for future BRUV use. Our study shows that BRUVs are a useful, time effective, non‐invasive technique to collect relative abundance and species richness estimates for freshwater turtles.

An Intelligent Framework for Estimating Software Development Projects using Machine Learning

The IT industry has faced many challenges related to software effort and cost estimation. A cost assessment is conducted after software effort estimation, which benefits customers as well as developers. The purpose of this paper is to discuss various methods for the estimation of software effort and cost in the context of software engineering, such as algorithmic methods, expert judgment methods, analogy-based estimation methods, and machine learning methods, as well as their different aspects. In spite of this, estimation of the effort involved in software development are subject to uncertainty. Several methods have been developed in the literature for improving estimation accuracy, many of which involve the use of machine learning techniques. A machine learning framework is proposed in this paper to address this challenging problem. In addition to being completely independent of algorithmic models and estimation problems, this framework also features a modular architecture. It has high interpretability, learning capability, and robustness to imprecise and uncertain inputs.

Study of Effort Calculation and Estimation in Open Source Projects

It is important to carefully monitor the development status of an open source projects because of the large number of people involved in the projects. One of the methods for evaluating project stability is earned value management (EVM), applying EVM to projects requires time-series effort data. However, there are few researches on the calculation of time-series effort data for open source projects, because open source projects do not manage effort as a whole. In this research, we have examined the validity of the calculation method and results of the time-series effort data in the open source projects. In addition, we have verified similarity of proprietary software development projects to open source projects in terms of effort. In particular, the similarity between open source projects and proprietary software development projects is verified by applying the effort data of open source projects to the software reliability growth model (SRGM).

Data-driven agile software cost estimation models for DHS and DoD

Problem:Since the Manifesto for Agile Software Development, the cost analysis community has struggled to find the most appropriate size measures for developing accurate agile software development cost estimates at an early phase to establish baseline budgets and schedules, and for the selection of competitive bidders. At this time, common agile sizing measures such as Story Points are not practical since these are reported months after contract award in the Department of Homeland Security (DHS) and Department of Defense (DoD). The problem is compounded with the lack of data to build estimation models for informed decisions. Aims:The primary objective is to investigate how well two new size measures (Functional Story and Issues) accurately relate to total effort, and how these compare and rank against four popular software size measures (Story, Story Point, Unadjusted Function Points, and Simple Function Points). The second objective is to rank the six sizing measures based on how well each estimate software development effort at an early phase or after contract award. Method:The experimental framework relied on an analysis of variance and goodness-of-fit tests to examine and compare the accuracy of effort estimation models using six competing size measures. The analysis is based on data from 17 agile projects implemented between 2014 to 2021. Results:Our two new size measures (Functional Story, Issues) proved to be good predicters of total software development effort. Functional Story is better at predicting total effort at early phase than Function Points and Story. Functional Story and Function Points are better at predicting total effort after contract award than Story Point and Issues. Conclusion:The DHS and DoD cost community can choose one or more of these estimation models to evaluate agile software development cost proposals or track agile developer’s progress after contract award.

Improved measurement of software development effort estimation bias

While prior software development effort estimation research has examined the properties of estimation error measures, there has not been much research on the properties of measures of estimation bias. Improved measurement of software development effort estimation bias. Analysis of the extent to which measures of estimation bias meet the criterion that perfect estimates should result in zero bias. Recommendations for measurement of estimation bias for estimates of the mean, median, and mode software development effort. The results include the recommendation to avoid a commonly used measure of effort estimation bias. Proper evaluation of estimation bias requires knowledge about the type of estimates evaluated, together with the selection of a measure of estimation bias that gives zero bias for perfect estimates of that type.

Software Effort Estimation Based on Use Case Reuse (Back Propagation)

Abstract: Project managers often use effort estimating strategies to manage the human resources of current or upcoming software projects. Prior to project implementation, cost, time, andpersonnel estimation are basically necessary. For every project of software, getting accuracy in Effort Estimation has always been difficult. In this study, the estimation of software development effort was determined using a back propagation model. This model's goal is to investigate the capabilities and potential uses of Utilizing artificial neural networks (ANN) as a tool for forecasting the effort required for software development. In order to estimate the software work, we are attempting to implement a machine learning technique in this research. Out of all machine learning methods, we are applying an algorithm based on Artificial Neural Networks that is Back propagation. The Desharnais dataset, a well-known publicly available dataset for estimation of software effort, is used to test the approach. The performance and accuracy of the tested model have been evaluated using three metrics: MMRE, MRE, and Pred (0.25). In the sections below that follows, I explain the algorithm and its results

CoBRA without experts: New paradigm for software development effort estimation using COCOMO metrics

AbstractSoftware development effort estimation (SDEE) is a critical activity in developing software. Accurate effort estimation in the early phases of software design life cycle has important effects on the success of software projects. COCOMO (Constructive Cost Model) is a parametric data‐driven SDEE model whose parameters must be calibrated with an organization's local data for accurate estimation. Such data are scarce for most organizations. On the other hand, CoBRA (Cost estimation, Benchmarking, and Risk Assessment) is one of the powerful hybrid methods that need a small number of local historical data for effort estimation. However, data gathering in CoBRA is time‐consuming and costly. To ease the use of CoBRA, in this paper, we design a methodology that extracts CoBRA‐required data from COCOMO datasets. By the proposed method, data collected for COCOMO would be used in CoBRA. Using CoBRA, a more accurate estimation of the required effort would be achieved with fewer number of historical data than what is required to calibrate the COCOMO model. We apply the proposed method on six well‐known public COCOMO datasets and use them in CoBRA. Obtained results depict an increase in the accuracy of estimations in comparison with other existing methods.

Agile Effort Estimation: Have We Solved the Problem Yet? Insights From a Replication Study

In the last decade, several studies have explored automated techniques to estimate the effort of agile software development. We perform a close replication and extension of a seminal work proposing the use of Deep Learning for Agile Effort Estimation (namely Deep-SE), which has set the state-of-the-art since. Specifically, we replicate three of the original research questions aiming at investigating the effectiveness of Deep-SE for both within-project and cross-project effort estimation. We benchmark Deep-SE against three baselines (i.e., Random, Mean and Median effort estimators) and a previously proposed method to estimate agile software project development effort (dubbed TF/IDF-SVM), as done in the original study. To this end, we use the data from the original study and an additional dataset of 31,960 issues mined from TAWOS, as using more data allows us to strengthen the confidence in the results, and to further mitigate external validity threats. The results of our replication show that Deep-SE outperforms the Median baseline estimator and TF/IDF-SVM in only very few cases with statistical significance (8/42 and 9/32 cases, respectively), thus confounding previous findings on the efficacy of Deep-SE. The two additional RQs revealed that neither augmenting the training set nor pre-training Deep-SE play lead to an improvement of its accuracy and convergence speed. These results suggest that using semantic similarity is not enough to differentiate user stories with respect to their story points; thus, future work has yet to explore and find new techniques and features that obtain accurate agile software development estimates.

Fuzzy Use Case Points as a Basis for Effort Estimation

Many software development projects encounter problems related to over- or under-estimation of effort. Accurate effort estimation is crucial for successful project management, but it can be challenging when resources are limited, and little is known about the project. The commonly used method for effort estimation is Use Case Points (UCP), which is mainly used for application-based objects and takes use cases as input. However, UCP has weaknesses, particularly in the high variation of weight factor values for Unadjusted Use Case Weight (UUCW). To address this problem, Fuzzy Use Case Points (FUCP), which is a combination of fuzzy logic and use case points, can be used. By applying fuzzy logic to the UUCW category, FUCP derives new weight factor values for UUCW. The implementation of FUCP to calculate effort estimation in ten government-based projects in this research has shown that FUCP yields the closest value to the actual effort required. It has also been demonstrated that FUCP outperforms UCP in terms of accuracy, with an improvement of 6.51%.