Use Case Points Research Articles

Evaluating the Quality of UCP-Based Framework using CK Metrics

Software effort estimation is one of the most important concerns in the software industry. It has received much attention since the last 40 years to improve the accuracy of effort estimate at early stages of software development. Due to this reason, many software estimation models have been proposed such as COCOMO, ObjectMetrix, Use Case Points (UCP) and many more. However, some of the estimation methods were not designed for object-oriented technology that actively encourages reuse strategies. Therefore, due to the popularity of UCP model and the evolution of the object-oriented paradigm, a UCP-based framework and supporting program were developed to assist software developers in building good qualities of software effort estimation programs. This paper evaluates the quality of the UCP-based framework using CK Metrics. The results showed that by implementing the UCP-based framework, the quality of the UCP-based program has improved regarding the understandability, testability, maintainability, and reusability.

Analyzing the relationship between project productivity and environment factors in the use case points method

Project productivity is a key factor for producing effort estimates from Use Case Points (UCP), especially when the historical dataset is absent. The first versions of UCP effort estimation models used a fixed number or very limited numbers of productivity ratios for all new projects. These approaches have not been well examined over a large number of projects so the validity of these studies was a matter for criticism. The newly available large software datasets allow us to perform further research on the usefulness of productivity for effort estimation of software development. Specifically, we studied the relationship between project productivity and UCP environmental factors, as they have a significant impact on the amount of productivity needed for a software project. Therefore, we designed four studies, using various classification and regression methods, to examine the usefulness of that relationship and its impact on UCP effort estimation. The results we obtained are encouraging and show potential improvement in effort estimation. Furthermore, the efficiency of that relationship is better over a dataset that comes from industry because of the quality of data collection. Our comment on the findings is that it is better to exclude environmental factors from calculating UCP and make them available only for computing productivity. The study also encourages project managers to understand how to better assess the environmental factors as they do have a significant impact on productivity

Software Size Estimation Using Activity Point

Software size is widely recognized as an important parameter for effort and cost estimation. Currently there are many methods for measuring software size including Source Line of Code (SLOC), Function Points (FP), Netherlands Software Metrics Users Association (NESMA), Common Software Measurement International Consortium (COSMIC), and Use Case Points (UCP). SLOC is physically counted after the software is developed. Other methods compute size from functional, technical, and/or environment aspects at early phase of software development. In this research, activity point approach is proposed to be another software size estimation method. Activity point is computed using activity diagram and adjusted with technical complexity factors (TCF), environment complexity factors (ECF), and people risk factors (PRF). An evaluation of the approach is present.

Analysis and selection of a regression model for the Use Case Points method using a stepwise approach

Software size estimation in software development projects depends on the number of use cases;All variables from the Use Case Points method have impact on a size estimation;Multiple Linear Regression models are considered;Stepwise Regression settings have been tested in this study;Multiple Linear Regression model concluded to be better than the Use Case Points method; This study investigates the significance of use case points (UCP) variables and the influence of the complexity of multiple linear regression models on software size estimation and accuracy.Stepwise multiple linear regression models and residual analysis were used to analyse the impact of model complexity. The impact of each variable was studied using correlation analysis.The estimated size of software depends mainly on the values of the weights of unadjusted UCP, which represent a number of use cases. Moreover, all other variables (unadjusted actors' weights, technical complexity factors, and environmental complexity factors) from the UCP method also have an impact on software size and therefore cannot be omitted from the regression model. The best performing model (Model D) contains an intercept, linear terms, and squared terms. The results of several evaluation measures show that this model's estimation ability is better than that of the other models tested. Model D also performs better when compared to the UCP model, whose Sum of Squared Error was 268,620 points on Dataset 1 and 87,055 on Dataset 2. Model D achieved a greater than 90% reduction in the Sum of Squared Errors compared to the Use Case Points method on Dataset 1 and a greater than 91% reduction on Dataset 2. The medians of the Sum of Squared Errors for both methods are significantly different at the 95% confidence level (p<0.01), while the medians for Model D (312 and 37.26) are lower than Use Case Points (3134 and 3712) on Datasets 1 and 2, respectively.

A Decision Support System to Choose Optimal Release Cycle Length in Incremental Software Development Environments

In the last few years it has been seen that many software vendors have started delivering projects incrementally with very short release cycles. Best examples of success of this approach has been Ubuntu Operating system that has a 6 months release cycle and popular web browsers such as Google Chrome, Opera, Mozilla Firefox. However there is very little knowledge available to the project managers to validate the chosen release cycle length. We propose a decision support system that helps to validate and estimate release cycle length in the early development phase by assuming that release cycle length is directly affected by three factors, (i) choosing right requirements for current cycle, (ii) estimating proximal time for each requirement, (iii) requirement wise feedback from last iteration based on product reception, model accuracy and failed requirements. We have altered and used the EVOLVE technique proposed by G. Ruhe to select best requirements for current cycle and map it to time domain using UCP (Use Case Points) based estimation and feedback factors. The model has been evaluated on both in-house as well as industry projects.

Regression Analysis Based Software Effort Estimation Method

Estimating the development effort of a software project in the early stages of the software life cycle is a significant task. Accurate estimates help project managers to overcome the problems regarding budget and time overruns. This paper proposes a new multiple linear regression analysis based effort estimation method, which has brought a different perspective to the software effort estimation methods and increased the success of software effort estimation processes. The proposed method is compared with standard Use Case Point (UCP) method, which is a well-known method in this area, and simple linear regression based effort estimation method developed by Nassif et al. In order to evaluate and compare the proposed method, the data of 10 software projects developed by four well-established software companies in Turkey were collected and datasets were created. When effort estimations obtained from datasets and actual efforts spent to complete the projects are compared with each other, it has been observed that the proposed method has higher effort estimation accuracy compared to the other methods.

A hybrid model for estimating software project effort from Use Case Points

Early software effort estimation is a hallmark of successful software project management. Building a reliable effort estimation model usually requires historical data. Unfortunately, since the information available at early stages of software development is scarce, it is recommended to use software size metrics as key cost factor of effort estimation. Use Case Points (UCP) is a prominent size measure designed mainly for object-oriented projects. Nevertheless, there are no established models that can translate UCP into its corresponding effort; therefore, most models use productivity as a second cost driver. The productivity in those models is usually guessed by experts and does not depend on historical data, which makes it subject to uncertainty. Thus, these models were not well examined using a large number of historical data. In this paper, we designed a hybrid model that consists of classification and prediction stages using a support vector machine and radial basis neural networks. The proposed model was constructed over a large number of observations collected from industrial and student projects. The proposed model was compared against previous UCP prediction models. The validation and empirical results demonstrated that the proposed model significantly surpasses these models on all datasets. The main conclusion is that the environmental factors of UCP can be used to classify and estimate productivity.

Algorithmic optimization method for effort estimation

This paper presents an improvement of an effort estimation method that can be used to predict the level of effort for software development projects. A new estimation approach based on a two-phase algorithm is used. In the first phase, we apply a calculation based on use case points (UCPs). In the second phase, we add correction values (a1, a2) obtained via least squares regression. This approach employs historical project data to refine the estimate. By applying the least squares regression approach, the algorithm filters out estimation errors caused by human factors and company practice.

Analysis of task effort estimation accuracy based on use case point size

The use case point (UCP) method is one of the most commonly used size estimation methods in software development. Applicability of UCP size for the project effort estimation is thoroughly investigated; however, little attention is devoted to the effort estimation of particular task types. The authors have created and cross-compared prediction models for estimating task-type efforts by means of UCP size using an Online analytical processing model and R packages on a set of 32 real-world projects, with the goal of facilitating analysis of the correlation between project sizes and effort required to complete task types. Requirements, scoping, functional specification, and functional testing task types have up to two times better estimation accuracies than project effort. Implementation has slightly better accuracy than the project effort, while the other task types are not correlated to the UCP size. Using estimates of the most correlated task types and other techniques, such as expert judgment for others, we improved the overall project effort prediction accuracy and decreased the error from 26 to 16%.

Tuning of Use Case Point (UCP) Analysis Parameter using PSO

Test Effort Estimation is an important activity in software development. The test effort can be calculated on the basis of effort cost and time required for testing. Several studies have been done for developing test effort estimation models but to some extent only, most of these models result in erroneous results. So there is a strong need to optimize the efforts estimated. Meta heuristic techniques can be used for this purpose, to optimize a problem by iteratively trying to improve a solution, using some computational methods. In this paper, we have implemented meta-heuristic based search algorithm namely PSO. The particle swarm optimization algorithm is used for improving testing effort estimation. The particle swarm optimization algorithm (PSO) is applied on use case point (UCP) and results led us to the conclusion that test effort estimation can be optimized by applying PSO. The PSO optimization can also be applied for estimating efforts of software development. This implementation increases the accuracy of testing effort estimation.

Advancement Of UCP With End User Development Factor: AUCP

Computer literacy and competitive pressures among end users is increasing day by day due to whichthe need for End-User Programming in software packages is also increasing for rapid, flexible, and user driven information processing solutions. End User Development out-sources development effort to the end user by enabling softwaredevelopers to create information systems that can even be adapted by technically inexperienced endusers and hence are in great demand. If end user decides to pay the price and add significant programmability to their system, there are additional costs to consider before end user can start to enjoy the payoff. It is important to calculate accurateand early estimation of software size forcalculating effort and cost estimation of software systems incorporating EUD features. With the evolution of object orientation, use cases emerged as a dominant method for structuring requirements. Use cases were integrated into the Unified Modeling Language (UML) and Unified Process and became the standard for Software Engineering requirements modelling. The Use Case Point (UCP)methodestimates project size by assigning points to use cases in the same way that Function Point Analysis (FPA) assigns points to functions. This paper discusses the concept of end-user programming and Advancement of UCP by adding end-user development/programming as an additional Effort Estimation Factor (EEF).

Effort Distribution to Estimate Cost in Small to Medium Software Development Project with Use Case Points

Abstract The Use Case Points (UCP) has been a method that often used as a reference to calculate effort estimation, the amount of worker and time required in software development project. In Reality, software project planning has not been only effort estimation, but also cost estimation to estimate how much cost of resource allocation spent in software development. Result of the effort estimation using UCP is the number of effort required to develop the software as a whole. In fact, the determination of the cost of software development is based on the cost per activity of pay rate different in each phase of software development. Therefore it requires the distribution of effort per activity to get the cost of software development. To produce cost estimation in the software development project, we need to know the percentage of each phase of software development, in this case called the effort distribution. The percentage of effort distribution was obtained through the collection of empirical data of governance's software development in small to medium scale. In this study, it was used 15 small and medium-sized projects of software development in Indonesia that was completed. The findings of this study was the value of the percentage of effort to the three categories of phases of the software development, namely: the percentage of the phase of software development at 72.6%, the percentage of the phase of the on-going life-cycle activities amounted to 17.5%, and a phase of quality control and testing amounted to 9.9%. While the percentage of detail presented in this paper. Another result of this study was the steps to determine the estimated costs for software development with UCP method.

Idea Creation: Function Synthesis Approach with Simplification and Evaluation

Product engineer is being required to design attractive products in a short product development cycle from stakeholder. And, its attraction is influenced a great deal by idea creation in a conceptual design phase of this cycle. On the other hand, K. Yoshioka and H. Hasegawa proposed the FSA (Function Synthesis Approach) to create a combination of a large number of functions in a short period of time. FSA become a conceptual design support tool that combines the PSO (Particle Swarm Optimization) and the particle method of USIT. However, FSA is only to outputting combination of large numbers of functions. For this reason, there is a need to provide a way to support the conceptual design process systematically. Therefore, this paper proposes a method to systematically support the conceptual design process from the output of the FSA. This systematic process is consisted from two phases. First, the design solution is built by combination of large number of function via using axiomatic design and function structure method. Next, it is evaluated by using UCP (Use Case Points) method. And, this paper described these phases via example to the refrigerator.

Function Point an Effective Planning Tool

Prerequisite of every estimation technique is effective requirement discovery and planning. FP is observed to be good source of initial planning. While using Function Point (FP), the whole application is brainstormed. Application is planned with gathering all inputs, outputs, inquiries, external interfaces and files. Whereas use case point (UCP) are limited to identifying actor, and use cases. UCP is not effective in initial planning. Research presented in this paper takes advantage by combining UCP with FP model in identifying objects like (External Inputs, External Outputs, External Inquiries, External Interface files, Internal Logical files, and others) for each use case. That will help in effective planning of project at initial stages of application. Results show that by combining the FP model and UCP model, component identification enhances by 66 %.

An Early Software Effort Estimation Method Based on Use Cases and Conceptual Classes

It is an important issue in the software industry to predict how much effort will be required for a software project as early as possible. Software size is one of the commonly used attributes in effort estimation. In this paper, we propose an early software size and effort estimation method based on conceptual model of the problem domain. Our method utilizes the noteworthy domain concepts identified mainly from the use cases written in the requirements phase of the software development lifecycle. In order to develop the model and evaluate its prediction quality, the use cases written and the effort data collected for 14 industrial software development projects of a CMMI level 3 certified defense industry company have been used. Evaluation results reveal a high correlation between the number of conceptual classes identified (i.e., domain objects) during the requirements analysis, the number of classes constituting the resulting software and the actual effort spent. Moreover, we have used the use case point (UCP) method to estimate the effort needed for each project and compared the results of UCP analysis with the results obtained with our method. The comparisons have shown that, for the projects considered, our method gives a better effort estimation compared to the effort estimated by using the UCP method.

1.4.3 Applying Systems Engineering Modeling Language (SysML) to System Effort Estimation Utilizing Use Case Points

AbstractThis paper proposes that as model based systems engineering begins to play a larger role in system development it may be utilized in estimating systems effort, making model based systems engineering more valuable to system engineering. This paper proposes to extend the Use Case Points (UCP) estimating approach, used by some software engineers, to SysML for estimating the systems engineering effort. The paper reviews literature that encourages the notion of a UCP method for Systems Engineering (UCPSE). Finally the paper maps out the research plan to develop and validate the UCPSE method.

Improving the reliability of transaction identification in use cases

Context: The concept of transactions is used in Use Case Points (UCP), and in many other functional size measurement methods, to capture the smallest unit of functionality that should be considered while measuring the size of a system. Unfortunately, in the case of the UCP method at least four methods for use-case transaction identification have been proposed so far. The different approaches to transaction identification and difficulties related to the analysis of requirements expressed in natural language can lead to problems in the reliability of functional size measurement. Objective: The goal of this study was to evaluate reliability of transaction identification in use cases (with the methods mentioned in the literature), analyze their weaknesses, and propose some means for their improvement. Method: A controlled experiment on a group of 120 students was performed to investigate if the methods for transaction identification, known from the literature, provide similar results. In addition, a qualitative analysis of the experiment data was performed to investigate the potential problems related to transaction identification in use cases. During the experiment a use-case benchmark specification was used. The automatic methods for transaction identification, proposed in the paper have been validated using the same benchmark by comparing the outcomes provided by these methods to on-average number of transactions identified by the participants of the experiment. Results: A significant difference in the median number of transactions was observed between groups using different methods of transaction identification. The Kruskal-Wallis test was performed with the significance level @a set to 0.05 and followed by the post-hoc analysis performed according to the procedure proposed by Conover. Also a large intra-method variability was observed. The ratios between the maximum and minimum number of transactions identified by the participants using the same method were equal to 1.96, 3.83, 2.03, and 2.21. The proposed automatic methods for transaction identification provided results consistent with those provided by the participants of the experiment and functional measurement experts. The relative error between the number of transaction identified by the tool and on-average number of transactions identified by the participants of the experiment ranged from 3% to 7%. Conclusions: Human-performed transaction identification is error prone and quite subjective. Its reliability can be improved by automating the process with the use of natural language processing techniques.

Simplifying effort estimation based on Use Case Points

Context The Use Case Points (UCP) method can be used to estimate software development effort based on a use-case model and two sets of adjustment factors relating to the environmental and technical complexity of a project. The question arises whether all of these components are important from the effort estimation point of view. Objective This paper investigates the construction of UCP in order to find possible ways of simplifying it. Method The cross-validation procedure was used to compare the accuracy of the different variants of UCP (with and without the investigated simplifications). The analysis was based on data derived from a set of 14 projects for which effort ranged from 277 to 3593 man-hours. In addition, the factor analysis was performed to investigate the possibility of reducing the number of adjustment factors. Results The two variants of UCP – with and without unadjusted actor weights (UAW) provided similar prediction accuracy. In addition, a minor influence of the adjustment factors on the accuracy of UCP was observed. The results of the factor analysis indicated that the number of adjustment factors could be reduced from 21 to 6 (2 environmental factors and 4 technical complexity factors). Another observation was made that the variants of UCP calculated based on steps were slightly more accurate than the variants calculated based on transactions. Finally, a recently proposed use-case-based size metric TTPoints provided better accuracy than any of the investigated variants of UCP. Conclusion The observation in this study was that the UCP method could be simplified by rejecting UAW; calculating UCP based on steps instead of transactions; or just counting the total number of steps in use cases. Moreover, two recently proposed use-case-based size metrics Transactions and TTPoints could be used as an alternative to UCP to estimate effort at the early stages of software development.

Analysis of Combining Software Estimation Techniques

paper, analysis of the result obtained from experiment with three projects is described. Combination of different estimation techniques helps estimator to reduce error and keep control over the deviation of estimates away from actual. As a response to survey from estimators working in software industry, It is revealed that, according to stages, estimates are termed as budgetary, initial, progressive and closure. As a budgetary estimates are dominated by analogy based estimation techniques, It can be complemented by COCOMO II Application Composition Model. The Initial estimates is average of COCOMO II Early Design model with Object point sizing, which can be complemented by Function point and Usecase point based estimation. The Progressive estimates are calculated by averaging of COCOMO II Post Architecture Model and Class point based estimates. It is observed that effort estimates are more accurate than using only COCOMO II. Keywordsestimation, Usecase point, Function point, Class point,

A mathematical reusability model for quantifying the reduction in development effort

Software Effort and Cost Estimation is a very important activity that includes very uncertain elements. In the context of object-oriented software, traditional methods and metrics were extended to help managing this activity. Use Case Points (UCP) is a very well known metrics used for estimation of object-oriented systems. Use case models are used in Object-Oriented Analysis for capturing and describing the Functional-Requirements of a system. Several methods for estimating software development effort are based on attributes of a use case model. In this paper, we propose a mathematical model based on vectors to measure reusability of software design in terms of reusability of the use cases. Increasing reusability of the use case model would lead to decrease in development effort. Using the vector model, we propose an approach to measure Complexity Reduction Factor (CRF) which measures percentage decrease in effort and hence in cost with increasing reusability. This quantitative analysis of effort reduction with increased reusability would enable us in designing reusable and cost effective software much earlier in software development life cycle, right at the requirement engineering phase. We have used requirements of an Insurance system as a case study to illustrate our approach.