Three Methods for Quantifying Software Development Effort Uncertainty

Software cost estimation is a process of planning, risk analysis, and decision making for project management in software development. Cost of project development encompasses a software project’s effort and development time. One popular model of software cost estimation is constructive cost model (COCOMO) model, which is a mathematical model proposed by Boehm, used for estimate the software effort and development time. The objective of this paper is to improve the basic COCOMO model’s coefficients for modern programming languages like Python, R, C++, etc. Many techniques were presented in the past for effort and time estimation using machine learning. But all these techniques were trained and tested for older programming languages. In order to improve the accuracy of COCOMO for modern programming languages, six Python projects have been considered and genetic algorithm (GA) is applied in these projects to define new values for basic COCOMO coefficients and the development time is calculated for Python projects. The time estimated using GA coefficients is compared with the original COCOMO and actual time. Using mean magnitude relative error, the error from the original COCOMO time is 54.49% and error from GA time is 21.23%.

Software 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.

The software cost estimation (SCE) problem is one of the major challenges in software engineering. Inaccurate cost and time estimation in a software project may lead to devastating damage to software companies. To deal with this issue, software researchers have made significant efforts during recent years to improve and modify the available SCE models, one widely-used model of which is the Constructive Cost Model (COCOMO). This research aims to optimize the coefficients of a standard COCOMO model for SCE by combining genetic algorithm (GA) and environmental adaptation (EA) methods. The results indicate that the EA algorithm can solve the divergence issue of the genetic algorithm and optimize the coefficients of the COCOMO model as well. Moreover, the accuracy of the SCE in the case of combining GA and EA algorithms is 8% higher than when these algorithms are separately adopted.

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.

Estimation of Software Development Effort from Requirements Based Complexity

Playing a pivotal role in software development, the Constructive Cost Model (COCOMO) offers a systematic and structured approach to cost estimation. It stands as a widely utilized model, aiding project managers in estimating the required effort, time, and cost for software development projects. COCOMO takes into consideration diverse factors, including the project's size, complexity, and the experience of the development team. The utilization of COCOMO empowers software development teams to make informed decisions related to resource allocation, project scheduling, and budgeting. Its application extends to managing expectations, enhancing project planning, and mitigating the risk of cost overruns. The integration of machine learning assumes a critical role in advancing cost estimation within the realm of software development, specifically through COCOMO. Through the utilization of machine learning algorithms, COCOMO gains the capability to analyze and interpret extensive datasets, taking into account numerous complex factors that influence project costs. This work aims to propose a model for software cost estimation using an advanced machine learning technique, i.e. Adaptive boosting, which has improved accuracy, reduced overfitting, effectiveness with imbalanced data, and good generalization capabilities. The proposed work may contribute to the success of software projects, providing a reliable and comprehensive framework for cost estimation.

Estimating effort is a very important task in any organization. Significant over or under-estimates can be very expensive for software project companies. The use of computing intelligence methods has been recently proposed for software development effort estimation. In this study, we present new models to estimate the effort required for the development of software projects. These new models were calculated using Linear Genetic Programming (PGL). The results show that the proposed models get more precise and more effective estimation for Mean Magnitude Relative error (MMRE) and Mean Magnitude of Relative Error relative to the Estimate (MMER) than using the constructive cost model (COCOMO). We performed the study based on three stages according to the type of project. The models were designed and validated by simulation with the public repository dataset COCOMO81 and NASA93. Performance of the proposed models EE_PGLa, EE_PGLb and EE_PGLc are more accurate than COCOMO.

Mastering the increased complexity of today's programmable electronic systems (PES) is topic of many research and development projects. The risen complexity in real time embedded-systems has been identified as a barrier for a fast time-to-market product development in many projects. At the same time, more and more flexibility, scalability and distributed intelligence are required for new PES. But what does it mean in detail that a PES is more or less complex and how can complexity and its influence on the effort for developing a distributed PES be examined already in the design phase of a development project? This paper discusses a method to estimate complexity and development effort for distributed PES. In addition, the method can be used to compare different possible solutions to achieve an optimised design decision. Therefor, the effort estimation method COCOMO (Constructive Cost Model) was expanded for distributed PES (COCOMOdist). It was validated exemplarily within a practical development project (Distributed Burner Control), resulting in several interesting conclusions.

Prediction of software development is the key task for the effective management of any software industry. The accuracy and reliability of the prediction mechanisms used for the estimation of software development effort is also important. A series of experiments are conducted to gradually progress towards the improved accurate estimation of the software development effort. However, while conducting these experiments, it was found that the size of the training set was not sufficient to train a large and complex artificial neural network (ANN). To overcome the problem of the size of the available training data set, a novel multilayered architecture based on a neural network model is proposed. The accuracy of the proposed multi-layered model is assessed using different criteria, which proves the pre-eminence of the proposed model.

Software cost and time estimation is the process of estimating the cost and time required to develop a software system. Software cost and time estimation supports the planning and tracking of software projects. Effectively controlling the expensive investment of software development is one of the important issues in software project management. Estimating software development cost with high precision is still a great challenge for project managers, because it allows for considerable financial and strategic planning. Software cost estimation refers to the predictions of the likely amount of effort, time, and staffing levels required to build a software system. A very helpful form of cost estimation is the one made at an early stage during a project, when the costing of the project is proposed for approval. However, estimates at the early stages of the development are the most difficult to obtain. In this paper a novel Constructive Cost Model (COCOMO) based on soft computing approach is proposed for software cost estimation. This model carries some of the desirable features of neural networks approach, such as learning ability and good interpretability, while maintaining the merits of the COCOMO model. Unlike the standard neural networks approach, the proposed model can be interpreted and validated by experts, and has good generalisation capability. The model deals effectively with imprecise and uncertain input and enhances the reliability of software cost estimates. From the experimental results, it was concluded that, by the proposed neural network model, the accuracy of cost estimation can be improved and the estimated cost can be very close to the actual cost.

The estimation of software development effort has been centralized mostly on the accuracy of estimates through dealing with heterogeneous datasets regardless of the fact that the software projects are inherently complex and uncertain. In particular, Analogy Based Estimation (ABE), as a widely accepted estimation method, suffers a great deal from the problem of inconsistent and non-normal datasets because it is a comparison-based method and the quality of comparisons strongly depends on the consistency of projects. In order to overcome this problem, prior studies have suggested the use of weighting methods, outlier elimination techniques and various types of soft computing methods. However the proposed methods have reduced the complexity and uncertainty of projects, the results are not still convincing and the methods are limited to a special domain of software projects, which causes the generalization of methods to be impossible. Localization of comparison and weighting processes through clustering of projects is the main idea behind this paper. A hybrid model is proposed in which the software projects are divided into several clusters based on key attributes (development type, organization type and development platform). A combination of ABE and Particle Swarm Optimization (PSO) algorithm is used to design a weighting system in which the project attributes of different clusters are given different weights. Instead of comparing a new project with all the historical projects, it is only compared with the projects located in the related clusters based on the common attributes. The proposed method was evaluated through three real datasets that include a total of 505 software projects. The performance of the proposed model was compared with other well-known estimation methods and the promising results showed that the proposed localization can considerably improve the accuracy of estimates. Besides the increase in accuracy, the results also certified that the proposed method is flexible enough to be used in a wide range of software projects.

Fractionated Space Systems, as exemplified by Defense Advanced Research Projects Agency's Future Fast, Flexible, Fractionated, Free-Flying Spacecraft united by Information eXchange (DARPA’s System F6), represent real challenges to software cost estimation. The concept is a traditional 'monolithic' spacecraft is replaced by a cluster of wirelessly interconnected spacecraft modules to create a virtual satellite, delivering capability which is at least equivalent to the monolithic spacecraft. Concurrently, they significantly enhance flexibility and system robustness, and reduce risk throughout the mission life and the spacecraft development cycle. Such systems present real challenges to software cost estimation which arise from both the concept of a Directed System of Systems (DSOS) and the reduced risk which is primarily achievable only through the application of an Incremental Commitment Model (ICM). This paper will briefly introduce a next-generation synthesis of the spiral model and other leading process models into the ICM, which is being piloted or considered for adoption in some parts of Department of Defense (DoD). The ICM emphasizes architecting systems (or DSOSs) to encapsulate subsystems (or systems) undergoing the most rapid change; and architecting the incremental development process by having agile systems engineers handling longer-range change traffic to rebaseline the plans for future increments while largely plandriven teams develop and continuously verify and validate (V&V) the current increment, as is usually required for safe or secure software. One approach being followed for estimating the software development cost of the Fractionated Space Craft Systems of Systems (FSSOS) is based on the Constructive Incremental Commitment Cost Model (COINCOMO) model and its tool which currently implements together in one tool the Constructive Cost Model (COCOMO II), the Constructive Phased Schedule and Effort Model (COPSEMO) and a Constructive Security Cost Model (COSECMO). COINCOMO has an added super-structure to accommodate multiple suppliers of independent software subsystems and multiple builds (or incremental deliveries). Many software systems components today rely on Commercial-Off-the-Shelf (COTS) sub-components and/or reuse of (potentially proprietary) open-source or legacy components which are treated like COTS components rather than reused, modified components, and adapted/reused open-source subcomponents, as well as new code. The COINCOMO model also accommodates them without the name-space explosion that happened in COCOMO II. COINCOMO 2.0 is implemented in a database-centric fashion designed with the ability to save and reuse any of the sets of parameters thus making it much easier to do what-if and evolving estimates.

One of reliability engineering's long standing needs has been a credible and repeatable method for estimating the investments required to satisfy stated reliability requirements. This paper reports on the development of a mathematical model that can be used to predict the investment in reliability required to achieve a given amount of reliability improvement. An appropriate analogy is the constructive cost model (COCOMO) used to predict software development cost. Similar to COCOMO, the reliability investment model comprises a set of sub-models. We have developed three thus far: 1) a basic model that computes reliability development effort and cost as a function of program size and desired reliability improvement. Its purpose is to provide rough order of magnitude estimates when very limited program information is available, as is typical at the early stages of programs; 2) an intermediate model that computes development effort as a function of program size, desired reliability improvement, and a set of relevant cost drivers; and 3) a production and support cost model to estimate the variation of investment in production and the change in operations and support cost due to an improvement in reliability.

Background. Currently there are several definitions of measures that should represent the size of software functional requirements. These measures have gained a quite relevant role, since they are one of the few basis upon which effort estimation can be based. However, traditional Functional Size Measures do not take into account the amount and complexity of the elaboration required, concentrating instead on the amount of data accessed or moved. This is a problem, when it comes to effort estimation, since the amount and complexity of the required data elaborations affect the implementation effort, but are not adequately represented by the current measures (including the standardized ones).

Differential evolution using homeostasis adaption based mutation operator and its application for software cost estimation