Software development processes are split into a number of separate activities. Cost estimation of software development project focuses on how associating estimates of effort and time with the project activities. Estimation involves answering the following questions:
- How much effort is required to complete each activity?
- How much calendar time is needed to complete each activity?
- What is the total cost of each activity?
Project cost estimation and project scheduling are usually carried out together. The costs of development are primarily the costs of the effort involved, so the effort computation is used in both the cost and the schedule estimate. The initial cost estimates may be used to establish a budget for the project and to set a price for the software for a customer. The total cost of a software development project is the sum of following costs:
- Hardware and software costs including maintenance.
- Travel and training costs.
- Effort costs of paying software developers.
For most projects, the dominant cost is the effort cost. Effort costs are not just the salaries of the software engineers who are involved in the project. The following overhead costs are all part of the total effort cost:
- Costs of heating and lighting offices.
- Costs of support staff (accountants, administrators, system managers, cleaners, technicians etc.).
- Costs of networking and communications.
- Costs of central facilities (library, recreational facilities, etc.).
- Costs of social security and employee benefits such as pensions and health insurance.
The aim of software costing is to accurately predict the cost of developing the software. The price of software is normally the sum of development cost and profit. During the development project managers should regularly update their cost and schedule estimates. This helps with the planning process and the effective use of resources. If actual expenditure is significantly greater than the estimates, then the project manager must take some action. This may involve applying for additional resources for the project or modifying the work to be done.
Software productivity estimation
Productivity estimates help to define the project cost and schedule. In a software development project managers may be faced with the problem of estimating the productivity of software engineers. For any software problem, there may be many different solutions, each of which has different attributes. One solution may execute more efficiently while another may be more readable and easier to maintain and comparing their production rates is very difficult.
Productivity estimates are usually based on measuring attributes of the software and dividing this by the total effort required for development. Software metrics have two main types:
- Size-related software metrics. These metrics are related to the size of software. The most frequently used size-related metric is lines of delivered source code.
- Function-related software metrics. These are related to the overall functionality of the software. For example, function points and object points are metrics of this type.
The productivity estimation defined as lines of source code per programmer month is widely used software productivity metric. It is computed by counting the total number of lines of source code divided by the total development time in programmer-months required to complete the project.
In other cases, the total number of function points in a program measures or estimates the following program features:
- external inputs and outputs,
- user interactions,
- external interfaces,
- files used by the system.
Obviously, some features are more complex than others and take longer time to code. The function point metric takes this into account by application of a weighting factor. The unadjusted function point count (UFC) is computed by multiplying the number of a given feature by its estimated weight for all features and finally summing products:
UFC=∑(number of a given feature)×(weight for the given feature)
Object points are an alternative to function points. The number of object points is computed by the estimated weights of objects:
- Separate screens that are displayed. Simple screens count as 1 object point, moderately complex screens count as 2, and very complex screens count as 3 object points.
- Reports that are produced. For simple reports, count 2 object points, for moderately complex reports, count 5, and for reports that are likely to be difficult to produce, count 8 object points.
- Modules that are developed to supplement the database programming code. Each of these modules counts as 10 object points.
The final code size is calculated by the number of function points and the estimated average number of lines of code (AVC) required to implement a function point. The estimated code size is computed as follows:
The problem with measures based on the amount produced in a given time period is that they take no account of quality characteristics such as reliability and maintainability.