CS451 Lecture 5: Project Metrics and Estimation [Pressman, Cha pters 22, 23 ]

1. CS451Lecture 5: Project Metrics and Estimation[Pressman, Chapters 22, 23] CS451 - Lecture 5

2. A Good Manager Measures process process metrics project metrics measurement product metrics product What do we use as a basis? • size? • function? CS451 - Lecture 5

3. Why Do We Measure? • assess the status of an ongoing project • track potential risks • uncover problem areas before they go “critical,” • adjust workflow or tasks, • evaluate the project team’s ability to control quality of software work products. CS451 - Lecture 5

4. Process Measurement • We measure the efficacy of a software process indirectly. • Derive a set of metrics based on the outcomes that can be derived from the process. • Outcomes include • measures of errors uncovered before release of the software • defects delivered to and reported by end-users • work products delivered (productivity) • human effort expended • calendar time expended • schedule conformance • other measures. • We also derive process metrics by measuring the characteristics of specific software engineering tasks. CS451 - Lecture 5

5. Process Metrics • Quality-related • focus on quality of work products and deliverables • Productivity-related • Production of work-products related to effort expended • Statistical SQA data • error categorization & analysis • Defect removal efficiency • propagation of errors from process activity to activity • Reuse data • The number of components produced and their degree of reusability CS451 - Lecture 5

6. Project Metrics • used to minimize the development schedule by making the adjustments necessary to avoid delays and mitigate potential problems and risks • used to assess product quality on an ongoing basis and, when necessary, modify the technical approach to improve quality. • every project should measure: • inputs—measures of the resources (e.g., people, tools) required to do the work. • outputs—measures of the deliverables or work products created during the software engineering process. • results—measures that indicate the effectiveness of the deliverables. CS451 - Lecture 5

7. Typical Project Metrics • Effort/time per software engineering task • Errors uncovered per review hour • Scheduled vs. actual milestone dates • Changes (number) and their characteristics • Distribution of effort on software engineering tasks CS451 - Lecture 5

8. Typical Size-Oriented Metrics • errors per KLOC (thousand lines of code) • defects per KLOC • $ per LOC • pages of documentation per KLOC • errors per person-month • Errors per review hour • LOC per person-month • $ per page of documentation CS451 - Lecture 5

9. Typical Function-Oriented Metrics • errors per FP (thousand lines of code) • defects per FP • $ per FP • pages of documentation per FP • FP per person-month CS451 - Lecture 5

10. Comparing LOC and FP Representative values developed by QSM CS451 - Lecture 5

11. Why Opt for FP? • Programming language independent • Used readily countable characteristics that are determined early in the software process • Does not “penalize” inventive (short) implementations that use fewer LOC that other more clumsy versions • Makes it easier to measure the impact of reusable components CS451 - Lecture 5

12. Object-Oriented Metrics • Number of scenario scripts (use-cases) • Number of support classes (required to implement the system but are not immediately related to the problem domain) • Average number of support classes per key class (analysis class) • Number of subsystems (an aggregation of classes that support a function that is visible to the end-user of a system) CS451 - Lecture 5

13. WebE Project Metrics • Number of static Web pages (the end-user has no control over the content displayed on the page) • Number of dynamic Web pages (end-user actions result in customized content displayed on the page) • Number of internal page links (internal page links are pointers that provide a hyperlink to some other Web page within the WebApp) • Number of persistent data objects • Number of external systems interfaced • Number of static content objects • Number of dynamic content objects • Number of executable functions CS451 - Lecture 5

14. Measuring Quality • Correctness — the degree to which a program operates according to specification • Maintainability—the degree to which a program is amenable to change • Integrity—the degree to which a program is impervious to outside attack • Usability—the degree to which a program is easy to use CS451 - Lecture 5

15. Estimation Techniques • Past (similar) project experience • Conventional estimation techniques • task breakdown and effort estimates • size (e.g., FP) estimates • Empirical models • Automated tools CS451 - Lecture 5

16. Functional Decomposition Statement of Scope functional decomposition Perform a Grammatical “parse” CS451 - Lecture 5

17. Conventional Methods:LOC/FP Approach • compute LOC/FP using estimates of information domain values • use historical data to build estimates for the project CS451 - Lecture 5

18. Example: LOC Approach Average productivity for systems of this type = 620 LOC/pm. Burdened labor rate =$8000 per month, the cost per line of code is approximately $13. Based on the LOC estimate and the historical productivity data, the total estimated project cost is $431,000 and the estimated effort is 54 person-months. CS451 - Lecture 5

19. Example: FP Approach The estimated number of FP is derived: FPestimated = count-total x [0.65 + 0.01 x (Fi)] FPestimated = 375 organizational average productivity = 6.5 FP/pm. burdened labor rate = $8000 per month, the cost per FP is approximately $1230. Based on the FP estimate and the historical productivity data,the total estimated project cost is $461,000 and the estimated effort is 58 person-months. CS451 - Lecture 5

20. Process-Based Estimation Obtained from “process framework” framework activities application functions Effort required to accomplish each framework activity for each application function CS451 - Lecture 5

21. Process-Based Estimation Example Based on an average burdened labor rate of $8,000 per month, the total estimated project cost is $368,000 and the estimated effort is 46 person-months. CS451 - Lecture 5

22. Tool-Based Estimation project characteristics calibration factors LOC/FP data CS451 - Lecture 5

23. Estimation with Use-Cases Using 620 LOC/pm as the average productivity for systems of this type and a burdened labor rate of $8000 per month, the cost per line of code is approximately $13. Based on the use-case estimate and the historical productivity data, the total estimated project cost is $552,000 and the estimated effort is 68 person-months. CS451 - Lecture 5

24. Empirical Estimation Models General form: exponent effort = tuning coefficient * size usually derived empirically as person-months derived of effort required usually LOC but may also be function point either a constant or a number derived based on complexity of project CS451 - Lecture 5

25. COCOMO-II • COCOMO II is actually a hierarchy of estimation models that address the following areas: • Application composition model.Used during the early stages of software engineering, when prototyping of user interfaces, consideration of software and system interaction, assessment of performance, and evaluation of technology maturity are paramount. • Early design stage model. Used once requirements have been stabilized and basic software architecture has been established. • Post-architecture-stage model. Used during the construction of the software. CS451 - Lecture 5

26. The Software Equation A dynamic multivariable model E = [LOC x B0.333/P]3 x (1/t4) where E = effort in person-months or person-years t = project duration in months or years B = “special skills factor” P = “productivity parameter” CS451 - Lecture 5

27. Estimation for OO Projects-I • Develop estimates using effort decomposition, FP analysis, and any other method that is applicable for conventional applications. • Using object-oriented analysis modeling (Chapter 8), develop use-cases and determine a count. • From the analysis model, determine the number of key classes (called analysis classes in Chapter 8). • Categorize the type of interface for the application and develop a multiplier for support classes: • Interface type Multiplier • No GUI 2.0 • Text-based user interface 2.25 • GUI 2.5 • Complex GUI 3.0 CS451 - Lecture 5

28. Estimation for OO Projects-II • Multiply the number of key classes (step 3) by the multiplier to obtain an estimate for the number of support classes. • Multiply the total number of classes (key + support) by the average number of work-units per class. Lorenz and Kidd suggest 15 to 20 person-days per class. • Cross check the class-based estimate by multiplying the average number of work-units per use-case CS451 - Lecture 5

29. Estimation for Agile Projects • Each user scenario (a mini-use-case) is considered separately for estimation purposes. • The scenario is decomposed into the set of software engineering tasks that will be required to develop it. • Each task is estimated separately. Note: estimation can be based on historical data, an empirical model, or “experience.” • Alternatively, the ‘volume’ of the scenario can be estimated in LOC, FP or some other volume-oriented measure (e.g., use-case count). • Estimates for each task are summed to create an estimate for the scenario. • Alternatively, the volume estimate for the scenario is translated into effort using historical data. • The effort estimates for all scenarios that are to be implemented for a given software increment are summed to develop the effort estimate for the increment. CS451 - Lecture 5

30. The Make-Buy Decision CS451 - Lecture 5

31. Computing Expected Cost expected cost = (path probability) x (estimated path cost) i i For example, the expected cost to build is: expected cost = 0.30 ($380K) + 0.70 ($450K) build = $429 K similarly, expected cost (reuse) =$382K expected cost (buy) = $267K expected cost (contr) = $410K CS451 - Lecture 5