Use Case Points

From Square Root

See the Construction Estimation Report for the final results of all these calculations.

This is the first cut of a larger project estimation based on use case points as outlined in Estimating with Use Case Points by Mike Cohn^[1].

This wiki page is meant to demonstrate the process. The excel spreadsheet in Sharepoint is the definitive reference for true estimated values.

Contents 1 Unadjusted Use Case Weight 1.1 Unadjusted Actor Weight 1.2 Unadjusted Use Case Points 1.3 Adjusting for Technical Complexity 1.4 Adjusting for Environmental Efficiency 1.5 Adjusted Use Case Points 2 Deriving Size/Effort 2.1 Buffers 2.2 Final Estimate 2.3 Verification 2.4 MSE Adjustments 3 Adjusted Use Cases Points per Hour 4 References

Unadjusted Use Case Weight

Use Case	Transactions	Complexity	Weight
Agree on Definitions	8	Complex	15
Identify Assets and Goals	6	Average	10
Collect Artifacts	3	Simple	5
Categorize Requirements	3	Simple	5
Prioritize Requirements	7	Average	10
Inspect Requirements	4	Average	10
Perform Security Risk Assessment	7	Average	10
Select Security Elicitation Technique	5	Average	10
Elicit Security Requirements	6	Average	10
Perform Privacy Risk Assessment		Average	10
Select Privacy Elicitation Tehcniques		Average	10
Elicit Privacy Requirements		Average	10
Register New User	4	Average	10
Reset Password	2	Simple	5
Edit Profile	2	Simple	5
View User Profile	2	Simple	5
Log In	1	Simple	5
Log Out	1	Simple	5
Manage Project	15	Complex	15
Create Project	6	Average	10
Install Square Tool	6	Average	10
Integrate with Requisite Pro		Complex	15
Export Data		Average	10
Create or Edit Inspection Technique	3	Simple	5
Create or Edit Elicitation Technique	3	Simple	5
Teach Step	2	Simple	5
Close Step		Simple	5
Send Notification	4	Average	10
Choose Step		Simple	5
Manage Site		Average	10
Total			255

Unadjusted Use Case Weight

Complexity	Weight	Number of Use Cases	Product
Simple	5	12	60
Average	10	14	150
Complex	15	3	45
Total			255

Unadjusted Actor Weight

Actor	Actor Type	Weight
Requirements Engineer	Complex	3
Lead Requirements Engineer	Complex	3
Stakeholder	Complex	3
Site Administrator	Complex	3
System Administrator	Average	2
Requirements Consumer	Simple	1
Total		15

Unadjusted Use Case Points

Unadjusted Use Case Weight + Unadjusted Actor Weight = 255 + 15 = 270 Unadjusted Use Case Points

Adjusting for Technical Complexity

Philosophically, we want to avoid adjusting the use case point estimate to avoid injecting biases into the estimate. With this in mind, unless a factor is obviously applicable or not applicable, it will receive an average weight.

Factor	Weight	Assessment	Impact
Distributed system	2	5	10
Performance objectives	2	0	0
End-user efficiency	1	3	3
Complex processing	1	3	3
Reusable code	1	3	3
Easy to install	0.5	5	2.5
Easy to use	0.5	5	2.5
Portable	2	3	6
Easy to change	1	3	3
Concurrent use	1	3	3
Security	1	3	3
Access for third parties	1	5	5
Training needs	1	3	3
Total			47

Technical Complexity Factor = 0.6 + (0.01 * Technical Factor) = 0.6 + (0.01 * 47) = 1.07

Adjusting for Environmental Efficiency

Philosophically, we want to avoid adjusting the use case point estimate to avoid injecting biases into the estimate. With this in mind, unless a factor is obviously applicable or not applicable, it will receive an average weight.

Environmental Factor	Weight	Assessment	Impact
Familiar with the development process	1.5	3	4.5
Application experience	0.5	3	1.5
Object-oriented experience	1	3	3
Lead analyst capability	0.5	3	1.5
Motivation	1	5	5
Stable requirements	2	3	6
Part-time staff	-1	0	0
Difficult programming language	-1	3	-3
Total			18.5

Environment Complexity Factor = 1.4 + (-.03 * Environment Factor) = 1.4 + (-.03 * 18.5) = 0.845

Adjusted Use Case Points

Factor	Weight
Unadjusted Use Case Weight	255
Unadjusted Actor Weight	15
Technical Complexity Factor	1.07
Environmental Factor	0.845
Total Use Case Points	244

Total Use Case Points = (Unadjusted Use Case Weight (projected) + Unadjusted Actor Weight (actual)) * Technical Complexity Factor * Environmental Factor = (330 + 15) * 1.07 * 0.845 = 244

Deriving Size/Effort

We will assume 20 - 28 hours per use case points^[2].

Total Effort (low) = Number of Use Case Points * 20 = 244 * 20 = 4,880 hours

Total Effort (high) = Number of Use Case Points * 28 = 244 * 28 = 6,832 hours

Buffers

Steve McConnell compiled a list of rules of thumb that should be considered when calculating a schedule^[3]. We will consider some of the rules of thumb for building buffer into this estimate. The adjustments are applied to the original time estimate.

• Administrative and clerical support: 10%
• Configuration management support: 2%
• IT Support: 2%
• Scope Creep: 4%
• New language, tools (learning curve): 20%
• New development environment (learning curve, problems): 20%
• Total buffer = 58%

Estimate with buffers (low) = 7,710.4 hours

Estimate with buffers (high) = 10,794.56 hours

Final Estimate

8,000 - 11,000 hours

Verification

To verify I'm going to convert the use case total to function points and use COCCOMO to calculate another time estimate. This assumes that the size estimate is approximately correct. Conversion constants were taken from this table^[4].

Function points = 80% * Unadjusted Use Case Points = 80% * 255 = 204 function points.

This yields a LOC estimate of 8,160 according to the table.

COCOMO II (post architecture algorithm) gives the following high and low estimates.

• Optimistic = 23.7 person months = 3,792 hours
• Likely = 29.6 person months = 4,736 hours
• Pessimistic = 37.0 person months = 5,920 hours

I assume there are 160 in a single person month.

4,000 - 6,000 hours + buffers

This is a drastic divergence from the Use Case point estimates which indicates that architectural decisions are rolled into the use case point estimates.

This gives a rate of 2.04 LOC/hour to 1.36 LOC/hour.

MSE Adjustments

Sampling 6 MSE Teams that used Java or C# in past projects, teams produced on average 12,384 LOC during summer development. Assuming that teams in the past had approximately 2,760 hours of development time as we do this gives a coding rate of 4.48 LOC/hour.

Assuming we code at a similar rate we should be able to finish the 8,160 LOC in approximately 1,819 hours.

Adjusted Use Cases Points per Hour

This information will be used to determine how much functionality can be completed by the end of the project. For now it is based on the industry average data from above. Once sufficient team data is collected, this rate can be revisited.

Use Case	Transactions	Complexity	Weight	Adjusted Value	Time in Hours
Agree on Definitions	8	Complex	15	14	442
Identify Assets and Goals	6	Average	10	9	284
Collect Artifacts	3	Simple	5	5	158
Categorize Requirements	3	Simple	5	5	158
Prioritize Requirements	7	Average	10	9	284
Inspect Requirements	4	Average	10	9	284
Perform Security Risk Assessment	7	Average	10	9	284
Select Security Elicitation Technique	5	Average	10	9	284
Elicit Security Requirements	6	Average	10	9	284
Perform Privacy Risk Assessment		Average	10	9	284
Select Privacy Elicitation Tehcniques		Average	10	9	284
Elicit Privacy Requirements		Average	10	9	284
Register New User	4	Average	10	9	284
Reset Password	2	Simple	5	5	158
Edit Profile	2	Simple	5	5	158
View User Profile	2	Simple	5	5	158
Log In	1	Simple	5	5	158
Log Out	1	Simple	5	5	158
Manage Project	15	Complex	15	14	442
Create Project	6	Average	10	9	284
Install Square Tool	6	Average	10	9	284
Integrate with Requisite Pro		Complex	15	14	442
Export Data		Average	10	9	284
Create or Edit Inspection Technique	3	Simple	5	5	158
Create or Edit Elicitation Technique	3	Simple	5	5	158
Teach Step	2	Simple	5	5	158
Close Step		Simple	5	5	158
Send Notification	4	Average	10	9	284
Choose Step		Simple	5	5	158
Manage Site		Average	10	9	284
Total			255	237	7482

References

1. ↑ Cohn, Mike. "Estimating with Use Case Points", Mountain Goat Software
2. ↑ Schneider, Geri and Jason P. Winters. 1998. Applying Use Cases: A Practical Guide. Addison Wesley.
3. ↑ McConnell, Steve. Software Estimation: Demystifying the Black Art
4. ↑ Jones, Capers. Estimating Software Costs: Bringing Realism to Estimating, McGraw-Hill Osborne Media