*We have looked at how to capture requirements with Use Cases, but once this is done, how do you progress with the project? Derek tells us in this post about the Karner's Use Case Points*

*Method...*

__How long would this UML project take to develop?__As we have seen from our series of posts on use cases, they are an excellent way of capturing our user requirements. Before commencing development, it makes sense to estimate how long the development should take. It also makes sense to base that estimation on those use cases, given they are the requirements we are going to implement. There are several techniques we could use, but I would like to introduce you to the Karner method which was developed on 1993 by Gustav Karner. This method involves the studying of the system actors and use cases, weighting them according to complexity and then applying technical and environment factors. This process follows a number of steps:

1. Weight the actors

2. Weight the use cases

3. Calculate the unadjusted use case points (UUCP)

4. Determine the technical complexity factors

5. Determine the environmental factors

6. Calculate the Use Case Points (UCP)

__1. Weight the Actors__The first step of the process is to analyse the complexity of your actors. The level of complexity is divided into 3 Actor Types:

Actor Type |
Description |
Factor |

Simple |
API |
1 |

Average |
Interactive or protocol driven |
2 |

Complex |
Graphical Interface |
3 |

Assign an actor type to each of your actors and then use the formula to calculate the total weighting

**Σ(Number of each Actor type * Appropriate Factor)**

**Simple**actor represents a separate entity which can be communicated with via an API. This means that interactions with the actor should be simple top implement. The multiplication factor for a simple actor is 1.

**Average**actors represent an entity which communicates by a defined protocol such as TCP/IP or RS232. This represents a more complicated interaction and thus the multiplication factor is 2.

**Complex**actors represent a person interacting with the system through a user interface. Obviously this interaction process is very complicated and therefore warrants the highest multiplication factor of 3.

Once you have weighted your actors you need to add up the total number of each actor type and then multiply the 3 totals by the appropriate multiplication factor. These values then need to be added together.

__2. Weight the Use Cases__The next step is to analyse the complexity of your actors. The level of complexity is divided into 3 use case types:

Use case Type |
Description |
Factor |

Simple |
3 or Fewer transactions |
5 |

Average |
4 to 7 Transactions |
10 |

Complex |
More than 7 transactions |
15 |

Once you have weighted the actors we need to weight the use cases themselves. For each scenario in our use case we need to calculate the number of transactions. A transaction is described as the completion of a request from a primary actor by information being dispatched to all relevant supporting actors

**Σ(Number of each use case type * Appropriate Factor)**

__3. Calculate the Unadjusted Use Case Points (UUCP)__Once the number of transactions for each use case has been determined, you should weight them as described in the above table. We then follow the same equation which was presented for the actor weighting.

Once we have this total we can calculate the unadjusted use case points (

**UUCP**) by adding the two weighting totals together.**Unadjusted Use Case Points = Actor weighting + Use Case Weighting**

__4. Determine the Technical Complexity Factor__Now we need to determine the technical complexity of the project, this process involves us analysing each entry in the table and assigning a rating between (0-5) for each row.

Factor Number |
Description |
Factor |

T1 |
Distributed system |
2 |

T2 |
Response performance Objectives |
1 |

T3 |
End-user efficiency (online) |
1 |

T4 |
Complex internal processing |
1 |

T5 |
Code must be reusable |
1 |

T6 |
Easy to install |
0.5 |

T7 |
Easy to Use |
0.5 |

T8 |
Portable |
2 |

T9 |
Easy to change |
1 |

T10 |
Concurrent |
1 |

T11 |
Security |
1 |

T12 |
Third Party Access |
1 |

T13 |
User Training |
1 |

A rating of 0 indicates that the factor is irrelevant for this particular project and therefore will not enter into our calculation. A value of 5 indicated a high importance and the fact that the item is essential in your project. Once you have justified your decisions you can multiply each element by its weighting factor. The summation of these values gives you the TFactor for your project:

**Tfactor = Σ(Rating * Factor**)

Now calculate the Technical Complexity Factor using the following formula:

**TCF = 0.6 + (0.01 * TFactor)**

__5. Determine the Environmental Factor__We now need to consider the people working within our team. They will have different strengths and experiences. This factor is called the Environmental Factor (EF). To calculate the EF we follow a similar procedure to that discussed for the TCF. As before we have to analyse each entry in the table and assign a rating between (0-5) for each row.

Factor Number |
Description |
Factor |

E1 |
Familiarity with RUP |
1.5 |

E2 |
Application Experience |
0.5 |

E3 |
OO Experience |
1 |

E4 |
Lead analyst capabilities |
0.5 |

E5 |
Motivation |
1 |

E6 |
Stable requirements |
2 |

E7 |
Part-time workers |
-1 |

E8 |
Difficult programming language |
-1 |

A rating of 0 indicates that we have no experience in the field. A value of 5 means that we are experts in this area. Again, once you have justified your decisions you can multiply each element by its weighting factor. The summation of these values gives you the EFactor for your project:

**Efactor = Σ(Rating * Appropriate Factor)**

Now calculate the Environmental Factor using the following formula:

**EF = 1.4 + (-0.03 * EFactor)**

__6. Calculate the Use Case Points (UCP)__Once you have calculated the 3 factor readings (UUCP, TCF and EF) we can multiply them together to give us the use case points (UCP) for our project.

**UCP = UUCP * TCF * EF**

We can use this value to estimate how long the project should take to develop. The Karner process suggests a value of 20 man hours per UCP for this estimation, so to estimate project duration use this formula:

**Project man-hours = 20 * UCP**

With experience, this figure can be refined, personally I believe people this figure should be increased when dealing with large teams as team cohesion becomes a bigger issue.

For a more accurate estimate you can add the number of environmental factors 1 to 6 that are above 3 to the number of factors in 7 and 8 that are below 3. If the total is 2 or less the figure of 20 hours is used. If the value is 3 or 4 a value of 28 should be used to calculate the project man hours.

**Based on the above, I would be interested to hear what people think could be done to improve reduce a projects estimated cost?**

*We have developed a Use Case Estimation Tool to assist you in successfuly managing your projects.*

*Go to our website to find out how this could support you and your project...*

*Taken from our blog - The Technical Diaires*