Mean Magnitude Of Relative Error Research Articles

Software cost and effort estimation using dragonfly whale optimized multilayer perceptron neural network

This paper proposed a Constructive Rapid Application Development Model based Software Cost Estimation Technique (CORADMO based SCET) for accurate software cost estimation. The data requirements, cost drivers, constraints and priorities are given as an input to the Fuzzy Inference System (FIS). The processed output such as effort, time and cost for nominal plan, shortest schedule plan, and least cost plan are computed in the Fuzzy Inference System (FIS). Further to reduce the effort time and cost means, the output optimized by Dragon fly Whale Optimization (DWO)which provides the best estimated effort, time and cost as an output for software development. The proposed CORADMO based SCET model is evaluated by NASA 93 dataset using MATLAB. The performance of the CORADMO based SCET approach is assessed in terms of Mean Magnitude of Relative Error, Pred (25%), and Magnitude of Relative Error attains the values of 98.77%, 92.55%, and 93.45% respectively. Finally, the CORADMO based SCET model justifies the suitability of Dragon fly Whale Optimization with the proposed fuzzy logic.

A Hybrid Artificial Bee Colony and Artificial Fish Swarm Algorithms for Software Cost Estimation

Software cost estimation (SCE), estimating the cost and time required for software development, plays a highly significant role in managing software projects. A somewhat accurate SCE is necessary for a software project to be successful. It allows effective control of construction time and cost. In the past few decades, various models have been presented to evaluate software projects, including mathematical models and machine learning algorithms. In this paper, a new model based on the hybrid of the artificial fish swarm algorithm (AFSA) and the artificial bee colony (ABC) algorithm is presented for SCE. The initial population of AFSA, which includes the values of the effort factors, is generated using the ABC algorithm. ABC algorithm is used to solve the problems of the AFSA algorithm such as population diversity and getting stuck in a local optimum. ABC algorithm achieves the best solutions using observer and scout bees. The evaluation of the combined method has been implemented on eight different data sets and evaluated based on eight different criteria such as mean magnitude of relative error and PRED (0.25). The proposed method is more error-free than current SCE methods, according to the results. The error value of the proposed method is lower on NASA60, NASA63, and NASA93 datasets.

A NONLINEAR REGRESSION MODEL FOR EARLY LOC ESTIMATION OF OPEN-SOURCE KOTLIN-BASED APPLICATIONS

Context. The early lines of code (LOC) estimation in software projects holds significant importance, as it directly influences the prediction of development effort, covering a spectrum of different programming languages, and open-source Kotlin-based applications in particular. The object of the study is the process of early LOC estimation of open-source Kotlin-based apps. The subject of the study is the nonlinear regression models for early LOC estimation of open-source Kotlin-based apps. Objective. The goal of the work is to build the nonlinear regression model with three predictors for early LOC estimation of open-source Kotlin-based apps based on the Box-Cox four-variate normalizing transformation to increase the confidence in early LOC estimation of these apps. Method. For early LOC estimation in open-source Kotlin-based apps, the model, confidence, and prediction intervals of nonlinear regression were constructed using the Box-Cox four-variate normalizing transformation and specialized techniques. These techniques, relying on multiple nonlinear regression analyses incorporating multivariate normalizing transformations, account for the dependencies between variables in non-Gaussian data scenarios. As a result, this method tends to reduce the mean magnitude of relative error (MMRE) and narrow confidence and prediction intervals compared to models utilizing univariate normalizing transformations. Results. An analysis has been carried out to compare the constructed model with nonlinear regression models employing decimal logarithm and Box-Cox univariate transformation. Conclusions. The nonlinear regression model with three predictors for early LOC estimation of open-source Kotlin-based apps is constructed using the Box-Cox four-variate transformation. Compared to the other nonlinear regression models, this model demonstrates a larger multiple coefficient of determination, a smaller value of the MMRE, and narrower confidence and prediction intervals. The prospects for further research may include the application of other data sets to construct the nonlinear regression model for early LOC estimation of open-source Kotlin-based apps for other restrictions on predictors.

Activity-based function point complexity of use case diagrams for software effort estimation

This study proposes a Function Point Analysis (FPA) based software development effort estimation methodology integrated with Use Case Diagrams. These methods include identifying actor activities, classifying those activities into FPA categories, and calculating Unadjusted Function Points (UFP). Followed by the calculation of Technical Complexity Factors (TCF) and Adjusted Function Points (AFP), this study aims to produce more accurate man-hours estimates. Results show a UFP of 162 TCF of 11, AFP of 123.12, and an estimated effort of 1846.8 hours worked, while the actual effort is 1228 hours. Evaluation of estimates using the metrics Mean Magnitude of Relative Error (MMER) 0.34, Mean Magnitude of Relative Error (MMRE) 0.50, Mean Absolute Error (MAE) 618.80, Mean Balanced Relative Error (MBRE) 0.50, Mean Inverse Balanced Relative Error (MIBRE) 0.34, and Root Mean Squared Error (RMSE) 618.80, showed sufficient precision despite the overestimation. The study suggests the need for adjustments in TCF calculations and considering development environment factors in more detail to improve estimation accuracy. These findings are essential in improving the precision of effort estimation methodologies in software development, particularly in projects that use Use Case Diagrams as the primary framework.

MFLion‐DMN: Mayfly Lion‐optimized deep maxout network for prediction of software development effort

AbstractThe precise evaluation of predicting software development effort is a serious process in software engineering. The underestimates require more time, which seems to be the negotiation of complete efficient design and complete software testing. Thus, this paper devises a novel model for inspecting the effort taken for the design of software. The Mayfly Lion Optimization (MFLion) algorithm is devised, which ensembles the Mayfly Algorithm (MA) with the Lion Optimization Algorithm (LOA) for precise estimation. The deep maxout network (DMN) is adapted wherein the different weights are produced out of which the most suitable is infused considering the MFLion during model training. The optimal features are selected using recursive feature elimination (RFE) wherein the best features are selected and the remaining irrelevant features are eliminated from the list. The proposed MFLion obtained better performance with the smallest mean magnitude of relative error (MMRE) of 5.909 and the smallest root mean square error (RMSE) of 75.505, respectively. Each technique is produced using a separate database generated using the Promise software engineering repository. The outcomes produced from the assessment of the accuracies of models suggested that the MFLion‐DMN is a substitute to forecast software effort, which is extensively devised in engineering platforms.

AGILE ESTIMATIONS: EMPIRICAL STUDY USING WEIGHTED COMPLEXITY FACTORS

Software time and cost estimates are always challenging due to the quickly changing software process. Especially Agile project estimations are complex, and the story points differ from person to person. Due to the person-to-person variations, project managers have difficulty arriving at the project cost for development projects with different sizes or complexity of systems/software. This paper proposes a new estimation model named the WEighted COmplexity Factor Estimation (WECOFE) Model to reduce the complexities of Agile story point estimations. Weighted complexities factors identify Low, Moderate, and High Project Level Factors and Story Level Factors. For each level, multiple factors were defined. Derived Weighted complexity based on Project, Requirement, and Resource Level factors. Each story's point estimation is explained based on weighted complexity defined and assigned factors values. Conducted study on various industry projects, showing that the WECOFE approach is promising by observing the Magnitude of Relative Error (MRE) and Mean Magnitude of Relative Error (MMRE). Also, performed a t-test for one sprint project with 51 stories, and paired sample means are equal for WECOFE with actual story points spent by the team.

Deep learning based one step and multi‐steps ahead forecasting blood glucose level

AbstractEnabling diabetic patients to predict their Blood Glucose Levels (BGL) is a crucial aspect of managing their metabolic condition, as it allows them to take appropriate measures to avoid hypo or hyperglycemia. Machine Learning (ML) and Deep Learning (DL) techniques have made this possible, and this paper evaluates and compares the performance of five distinct ML/DL models including: Convolutional Neural Network (CNN), Long Short Term Memory (LSTM), Support Vector Regression (SVR), Gated Reccurent Unit (GRU) and Deep Belief Network (DBN) for forecasting BGL, by applying two different forecasting methods, namely One Step Ahead (OSF) and Multi‐Step Ahead (MSF) comprising five different variants. The performance is evaluated based on four metrics: Mean Absolute Error (MAE), Mean Magnitude Relative Error (MMRE), Root Mean Square Error (RMSE) and Predictive Level (PRED). Additionally, the statistical significance of the regressors was evaluated using the Scott‐Knott (SK) test, while the Borda Count (BC) voting system was employed to rank them. The results indicate that the best performance was achieved with OSF using GRU. Furthermore, the effectiveness of an MSF strategy depends on the ML/DL technique used, and the best combinations were DBN with DirRec, DBN with Recursive, SVR with Recursive and SVR with DirRec. Additionally, DirRec was found to be the best strategy, as it consistently ranked first regardless of the ML/DL technique used.

Identification of multiple radioisotopes through convolutional neural networks trained on 2-D transformed gamma spectral data from CsI(Tl) spectrometer

A study is conducted to improve the performance of Convolutional Neural Networks (CNNs)-based radioisotope identification (RIID). This study introduces a novel method to transform the dimensional structure of a radioisotope (RI) mixture spectra as training inputs, for the purpose of extending the receptive field and improving RIID performance of the model. The one-dimensional (1-D) composite spectra of radioisotopic mixtures as a dataset to be used as train and test data for a CNNs model are generated by linearly combining the normalized element gamma-ray spectra of single RIs obtained experimentally with the developed CsI(Tl) spectrometer. One more dataset for training and testing another a CNNs model is produced by reshaping the same 1-D composite spectra into two-dimensional (2-D) image data with multiple columns and rows. After the structure and hyper-parameters of the model are determined, each model is trained and tested with each of the two prepared datasets to simultaneously predict the probabilities as the relative count distributions for eight RI classes. The RIID performance of the CNNs model trained with the reshaped 2-D data is compared with that of the model trained with the 1-D data. The performance of each trained model is evaluated by mean magnitude of relative error (MMRE) as performance evaluation metrics. The results show that the model trained with 2-D inputs outperforms the model trained with 1-D inputs and effectively identifies unknown multiple radioisotopes. The proposed method to transform 1-D data into 2-D data represents a promising approach for the CNNs-based RIID of a scintillator spectrometer, especially when multiple peaks or RIs need to be resolved.

Prediction of Software Effort by Using Non-Linear Power Regression for Heterogeneous Projects Based on Use case Points and Lines of code

Software cost estimation is necessary for all software organizations for contract negotiation. Numerous researchers have worked over the last four decades to provide estimation models, which can estimate efforts as accurately as they could, but the continuous change in the development models and use of new programming languages requires the development of new techniques for effort estimation. The size of the project must be estimated to determine the effort involved, which is rely on the programming languages and techniques employed for its development. Use case points, object points, lines of code, and story points are a few of the size matrices that are used for estimation using algorithmic models. There are several estimating techniques for the estimation of algorithmic models for various development approaches, but none of them offers a unified model for effort estimation for procedural and object-oriented projects. This work identifies common parameters for object-oriented and procedural-oriented programming languages. After the identification of common parameters, a combined model is developed for the estimation of effort for object-oriented and procedural-oriented programming language projects. The model's input is the size, which is measured in use case points and lines of source code. Power regression analysis of non-linear regression is applied to design the proposed model is designed using. The identified common parameters are multiplied with the mathematical equation achieved by power regression analysis to estimate the development effort for heterogeneous projects. The proposed work is assessed with the mean magnitude of relative error (MMRE). The error calculated with the proposed model is -0.16. The values of MMRE are further compared with the existing techniques such as linear regression, case-based reasoning, ensemble model, radial basis function neural network, and fuzzy analytic hierarchy process, and it was perceptible from the result that the proposed model delivers minimum error. The proposed work delivers the highest accuracy for software project estimation with the least amount of error.

Estimasi Pengembangan Perangkat Lunak Dengan Use Case Size Point

In software development activities one of the stages that need to be known by the project manager and the client is the estimated effort. The estimation activity is used as a reference in determining the time and personnel involved in software development. There are several methods used in software estimation such as Function Point, COCOMO, and Use Case Point. However, there are still some shortcomings such as the subjective tendency to measure complexity and lack of calculation on technical factors and environmental factors. The estimation used in this study uses the Use Case Size Point method which is the development of the Use Case Point method. The results of the Use Case size Point were used to provide a more accurate evaluation of effort with 0.01 Mean Magnitude of Relative Error (MMRE) and 0.01 Mean Magnitude of Relative Error (MMER)

Propose-Specific Information Related to Prediction Level at x and Mean Magnitude of Relative Error: A Case Study of Software Effort Estimation

The prediction level at x (PRED(x)) and mean magnitude of relative error (MMRE) are measured based on the magnitude of relative error between real and predicted values. They are the standard metrics that evaluate accurate effort estimates. However, these values might not reveal the magnitude of over-/under-estimation. This study aims to define additional information associated with the PRED(x) and MMRE to help practitioners better interpret those values. We propose the formulas associated with the PRED(x) and MMRE to express the level of scatters of predictive values versus actual values on the left (sigLeft), on the right (sigRight), and on the mean of the scatters (sig). We depict the benefit of the formulas with three use case points datasets. The proposed formulas might contribute to enriching the value of the PRED(x) and MMRE in validating the effort estimation.

Class-Level Refactoring Prediction by Ensemble Learning with Various Feature Selection Techniques

Background: Refactoring is changing a software system without affecting the software functionality. The current researchers aim i to identify the appropriate method(s) or class(s) that needs to be refactored in object-oriented software. Ensemble learning helps to reduce prediction errors by amalgamating different classifiers and their respective performances over the original feature data. Other motives are added in this paper regarding several ensemble learners, errors, sampling techniques, and feature selection techniques for refactoring prediction at the class level. Objective: This work aims to develop an ensemble-based refactoring prediction model with structural identification of source code metrics using different feature selection techniques and data sampling techniques to distribute the data uniformly. Our model finds the best classifier after achieving fewer errors during refactoring prediction at the class level. Methodology: At first, our proposed model extracts a total of 125 software metrics computed from object-oriented software systems processed for a robust multi-phased feature selection method encompassing Wilcoxon significant text, Pearson correlation test, and principal component analysis (PCA). The proposed multi-phased feature selection method retains the optimal features characterizing inheritance, size, coupling, cohesion, and complexity. After obtaining the optimal set of software metrics, a novel heterogeneous ensemble classifier is developed using techniques such as ANN-Gradient Descent, ANN-Levenberg Marquardt, ANN-GDX, ANN-Radial Basis Function; support vector machine with different kernel functions such as LSSVM-Linear, LSSVM-Polynomial, LSSVM-RBF, Decision Tree algorithm, Logistic Regression algorithm and extreme learning machine (ELM) model are used as the base classifier. In our paper, we have calculated four different errors i.e., Mean Absolute Error (MAE), Mean magnitude of Relative Error (MORE), Root Mean Square Error (RMSE), and Standard Error of Mean (SEM). Result: In our proposed model, the maximum voting ensemble (MVE) achieves better accuracy, recall, precision, and F-measure values (99.76, 99.93, 98.96, 98.44) as compared to the base trained ensemble (BTE) and it experiences less errors (MAE = 0.0057, MORE = 0.0701, RMSE = 0.0068, and SEM = 0.0107) during its implementation to develop the refactoring model. Conclusions: Our experimental result recommends that MVE with upsampling can be implemented to improve the performance of the refactoring prediction model at the class level. Furthermore, the performance of our model with different data sampling techniques and feature selection techniques has been shown in the form boxplot diagram of accuracy, F-measure, precision, recall, and area under the curve (AUC) parameters.

NONLINEAR REGRESSION MODELS FOR ESTIMATING THE DURATION OF SOFTWARE DEVELOPMENT IN JAVA FOR PC BASED ON THE 2021 ISBSG DATA

Context. The problem of estimating the duration of software development in Java for personal computers (PC) is important because, first, failed duration estimating is often the main contributor to failed software projects, second, Java is a popular language, and, third, a personal computer is a widespread multi-purpose computer. The object of the study is the process of estimating the duration of software development in Java for PC. The subject of the study is the nonlinear regression models to estimate the duration of software development in Java for PC.
 Objective. The goal of the work is to build nonlinear regression models for estimating the duration of software development in Java for PC based on the normalizing transformations and deleting outliers in data to increase the confidence of the estimation in comparison to the ISBSG model for the PC platform.
 Method. The models, confidence, and prediction intervals of nonlinear regressions to estimate the duration of software development in Java for PC are constructed based on the normalizing transformations for non-Gaussian data with the help of appropriate techniques. The techniques to build the models, confidence, and prediction intervals of nonlinear regressions are based on normalizing transformations. Also, we apply outlier removal for model construction. In general, the above leads to a reduction of the mean magnitude of relative error, the widths of the confidence, and prediction intervals in comparison to nonlinear models constructed without outlier removal application in the model construction process.
 Results. A comparison of the model based on the decimal logarithm transformation with the nonlinear regression models based on the Johnson (for the SB family) and Box-Cox transformations as both univariate and bivariate ones has been performed.
 Conclusions. The nonlinear regression model to estimate the duration of software development in Java for PC is constructed based on the decimal logarithm transformation. This model, in comparison with other nonlinear regression models, has smaller widths of the confidence and prediction intervals for effort values that are bigger than 900 person-hours. The prospects for further research may include the application of bivariate normalizing transformations and data sets to construct the nonlinear regression models for estimating the duration of software development in other languages for PC and other platforms, for example, mainframe.

Machine Learning approach for Software Effort Estimation using Combination of Principal Component Regression and Neural Network

For software projects that deploy vital tasks, it is difficult to estimate the effort of a project. In order to anticipate a few hours of labour effort (either time or personal) to deploy or maintain the software programme, software measurement points must be used. It is difficult to predict the behavior of an application that is engaged in software development during the initial phases of the effort. The hybrid model technique is used in this paper. It is necessary to apply Supervised Learning techniques in the Machine Learning algorithm. It is further subdivided into different types, such as linear regression, logistic regression, SVM (Support Vector Machine) algorithm, Naive Bayes algorithm, PCR(Principal Component Regression) algorithm, (Neural Network)NNET algorithm, KNN (K-Nearest Neighbour) algorithm, K-means, Random Forest algorithm, Dimensionality reduction algorithms, Gradient boosting algorithm, and Ada Boosting algorithm, to name a few examples. PCR algorithm and the nnet algorithm have been utilised for hybrid method, as shown above. Predictions from JM1/Software have been used to create this data collection. With 10886 unique instances and 18 unique traits, this is a very large amount. Metrics for evaluating this system include Mean Absolute Error (MAE), Mean Relative Error (MRE), Mean Magnitude of Relative Error (MMRE), Percentage of Predictive Accuracy (PRED), and R-squared. Compared to single model approaches based on machine learning algorithms techniques, the proposed hybrid using principal component regression and neural networks produced the best results, as demonstrated by the results.

When should we (not) use the mean magnitude of relative error (MMRE) as an error measure in software development effort estimation?

The mean magnitude of relative error (MMRE) is an error measure frequently used to evaluate and compare the estimation performance of prediction models and software professionals. This paper examines conditions for proper use of MMRE in effort estimation contexts. We apply research on scoring functions to identify the type of estimates that minimizes the expected value of the MMRE. We show that the MMRE is a proper error measure for estimates of the most likely (mode) effort, but not for estimates of the median or mean effort, provided that the effort usage is approximately log-normally distributed, which we argue is a reasonable assumption in many software development contexts. The relevance of the findings is demonstrated on real-world software development data. MMRE is not a proper measure of the accuracy of estimates of the median or mean effort, but may be used for the accuracy evaluation of estimates of most likely effort.

An Optimized Neuro-Fuzzy Network for Software Project Effort Estimation

Estimating software effort is an essential project management practice. The software effort estimation is the process of predicting the time and efforts required in the development of software projects. Estimating software cost is a critical challenge during the planning stage. Due to the lack of availability of quality data and the dynamic nature of software development, accurate estimation is difficult. This paper proposes an efficient software cost estimation method for the Genetic Elephant Herding Optimization-based Neuro-Fuzzy Network (GEHO-based NFN). In this method, a neuro-fuzzy network (NFN) is used to predict the software efforts in terms of cost. The training of this NFN is optimized using the genetic elephant herding optimization (GEHO) method, which combines the features of the genetic algorithm (GA) and the elephant herding optimization (EHO) techniques. The performance of the developed method was evaluated using five historical & benchmark datasets from the industrial projects. These are based on the four widely used performance evaluation metrics, such as Mean magnitude of relative Error (MMRE), Median magnitude of relative error (MdMRE), Root Mean Square Error (RMSE), and Prediction Accuracy (PRED). The Comparative analysis and experimental results of the proposed method conclude that the performance of the GEHO-based NFN method is better than other popular soft computing methods like Linear regression, Support Vector Regression (SVR), Wavelet ANN (WNN), and Decision Tree (DT) based Software project effort estimation (SPEE) methods.

A NONLINEAR REGRESSION MODEL TO ESTIMATE THE SIZE OF WEB APPS CREATED USING THE CAKEPHP FRAMEWORK

Context. The problem of estimating the software size in the early stage of a software project is important because a software size estimate is used for predicting the software development effort, including Web apps created using the CakePHP framework. The object of the study is the process of estimating the size of Web apps created using the CakePHP framework. The subject of the study is the nonlinear regression models to estimate the size of Web apps created using the CakePHP framework.
 Objective. The goal of the work is the building the nonlinear regression model with three predictors for estimating the size of Web apps created using the CakePHP framework on the basis of the Box-Cox four-variate normalizing transformation to increase the confidence in early size estimation of these apps.
 Method. The model, confidence and prediction intervals of multiply nonlinear regression to estimate the size of Web apps created using the CakePHP framework are constructed based on the Box-Cox multivariate normalizing transformation for non-Gaussian data with the help of appropriate techniques. The techniques to build the models, confidence, and prediction intervals of nonlinear regressions are based on the multiple nonlinear regression analysis using the multivariate normalizing transformations. The techniques allow taking into account the correlation between dependent and independent variables in the case of normalization of multivariate non-Gaussian data. In general, this leads to a reduction of the mean magnitude of relative error, the widths of the confidence, and prediction intervals in comparison with nonlinear models constructed using univariate normalizing transformations.
 Results. Comparison of the constructed model with the nonlinear regression models based on the decimal logarithm and the BoxCox univariate transformation has been performed.
 Conclusions. The nonlinear regression model with three predictors to estimate the size of Web apps created using the CakePHP framework is constructed on the basis of the Box-Cox four-variate transformation. This model, in comparison with other nonlinear regression models, has a larger multiple coefficient of determination, a smaller value of the mean magnitude of relative error and smaller widths of the confidence and prediction intervals. The prospects for further research may include the application of other multivariate normalizing transformations and data sets to construct the nonlinear regression model to estimate the size of Web apps created using the other frameworks.

Data-driven project buffer sizing in critical chains

In critical chain project management, the probability of timely project completion can usually be increased by setting a suitable project buffer. Existing studies tend to explicitly construct a formula to calculate the project buffer size, but there is a lack of a data-driven framework that sizes the project buffer through mining the buffer related information hidden in the project data. Therefore, from a perspective that is different from the current studies, we propose a data-driven project buffer sizing approach to size the project buffer in a prediction manner in the project planning phase. Our approach first uses a full-factor design of experiments and Monte Carlo simulation to construct the required dataset. Then, support vector regression is adopted to train the project buffer prediction model. The parameters of the support vector regression are fine-tuned via grid search and cross validation. Extensive computational experiments on the PSPLIB J30 dataset are conducted to validate our approach. Six performance measures (i.e., the mean squared error, the mean magnitude relative error, the percentage relative error deviation, the proportion of project buffer consumed, the average project buffer size and the probability of exceeding the planned duration) are employed to assess our approach. The experimental results show that our approach is competitive compared to classical project buffer sizing methods.

Stacking regularization in analogy-based software effort estimation.

Analogy-based estimation (ABE) estimates the effort of the current project based on the information of similar past projects. The solution function of ABE provides the final effort prediction of a new project. Many studies on ABE in the past have provided various solution functions, but its effectiveness can still be enhanced. The present study is an attempt to improve the effort prediction accuracy of ABE by proposing a solution function SABE: Stacking regularization in analogy-based software effort estimation. The core of SABE is stacking, which is a machine learning technique. Stacking is beneficial as it works on multiple models harnessing their capabilities and provides a better estimation accuracy as compared to a single model. The proposed method is validated on four software effort estimation datasets and compared with the already existing solution functions: closet analogy, mean, median and inverse distance weighted mean. The evaluation criteria used are mean magnitude of relative error (MMRE), median magnitude of relative error (MdMRE), prediction (PRED) and standard accuracy (SA). The results suggested that the SABE showed promising performance for almost all the evaluation criteria when compared with the results of the earlier studies.

Blockchain-Based Software Effort Estimation: An Empirical Study

Context: The success or failure of any software development project significantly depends on the accuracy of its effort estimates. Software development effort estimation is the foundation for project bidding, budgeting, planning, and cost control. Problem: The literature shows that a lot of work has been done on software effort estimation. But still, there is a need for improvement in effort estimation by introducing new methodologies. The structured group-based and analogy-based effort estimations are the widely used estimation methods. Nevertheless, there are several shortcomings of using these methods such as lack of experts, lack of historical data, and biasness in expert opinion, which negatively affect the estimation results. Motivation: With the advancement of technologies, such limitations could be overcome. Such as leveraging the applicability of blockchain in several domains such as improvement in software development process and network security. Method: In this article, we have proposed a Blockchain-Based Software Effort Estimation (BBSEE) methodology to improve the software effort estimation. We employ the proposed method using Web and blockchain technologies. Moreover, we also proposed an evaluation criteria to assess the efficacy of the proposed method in terms of Mean Magnitude of Relative Error (MMRE), Mean Absolute Error (MAE), and percentage of successful predictions falling (PRED (25)). Result: We performed several case studies and analyses expert opinion of 52 organizations to present the efficacy of the proposed method. Conclusion: We observe that BBSEE method outperforms than expert judgment and analogy-based effort estimation methodologies in terms of software effort estimation.