A Software project was estimated at 864 Function Points. A six person team will be assigned to project consisting of a requirement gathering person, one designer, two programmers and two testers. The salary of the designer is Rs. 70.000 per month, requirement gatherer is Rs. 50,000 per month, programmer is Rs. 60.000 per month and a tester is Rs. 60,000 per month. Average productivity for the team is 12 FP per person month. Which of the following represents the projected cost of the project ?
Rs. 43,20,000
Understanding Software Project Cost Estimation
This problem asks us to calculate the projected cost of a software project based on its estimated size in Function Points (FP), the team assigned, their salaries, and their average productivity. Cost estimation is a critical part of software project planning. Function Point Analysis is one method used to estimate the size of a software project, which then helps in estimating the effort and cost.
Given Information for the Software Project
- Estimated Project Size: 864 Function Points (FP)
- Team Size: 6 persons
- Team Composition:
- 1 Requirement Gatherer
- 1 Designer
- 2 Programmers
- 2 Testers
- Monthly Salaries:
- Requirement Gatherer: Rs. 50,000
- Designer: Rs. 70,000
- Programmer: Rs. 60,000
- Tester: Rs. 60,000
- Average Productivity: 12 FP per person month
Step-by-Step Project Cost Calculation
Step 1: Calculate Total Effort Required
The project size is given in Function Points, and the team's average productivity is given in Function Points per person month. We can find the total effort required for the project in person months using the formula:
Total Effort (person months) = $\frac{\text{Total Function Points}}{\text{Average Productivity per person month}}$
Total Effort = $\frac{864 \text{ FP}}{12 \text{ FP/person month}}$
Total Effort = $72 \text{ person months}$
Step 2: Calculate Project Duration
We have a team of 6 people who will collectively contribute the total required effort of 72 person months. The project duration can be calculated by dividing the total effort by the number of people in the team:
Project Duration (months) = $\frac{\text{Total Effort (person months)}}{\text{Number of people in the team}}$
Project Duration = $\frac{72 \text{ person months}}{6 \text{ persons}}$
Project Duration = $12 \text{ months}$
This means the project is estimated to take 12 months to complete with this specific 6-person team.
Step 3: Calculate the Total Monthly Cost of the Team
Now, let's calculate the total salary cost for the entire team per month based on the given salaries and team composition.
| Role | Number of Persons | Salary per Person (Rs.) | Total Monthly Cost for Role (Rs.) |
|---|---|---|---|
| Requirement Gatherer | 1 | 50,000 | $1 \times 50,000 = 50,000$ |
| Designer | 1 | 70,000 | $1 \times 70,000 = 70,000$ |
| Programmer | 2 | 60,000 | $2 \times 60,000 = 120,000$ |
| Tester | 2 | 60,000 | $2 \times 60,000 = 120,000$ |
| Total Monthly Team Cost (Rs.) | $50,000 + 70,000 + 120,000 + 120,000 = 360,000$ | ||
The total monthly cost for the team is Rs. 360,000.
Step 4: Calculate the Projected Total Cost of the Project
The project is estimated to take 12 months, and the team's monthly cost is Rs. 360,000. The total projected cost is the product of the monthly cost and the project duration.
Total Projected Cost = Total Monthly Team Cost $\times$ Project Duration (months)
Total Projected Cost = Rs. $360,000 \times 12$
Total Projected Cost = Rs. $4,320,000$
Based on the Function Point estimation, team composition, salaries, and productivity, the projected cost of the software project is Rs. 4,320,000.
Summary of Calculation
- Project Size (FP): 864
- Productivity (FP/person month): 12
- Total Effort (person months): $864 / 12 = 72$
- Team Size: 6
- Project Duration (months): $72 / 6 = 12$
- Monthly Team Cost (Rs.): $(1 \times 50,000) + (1 \times 70,000) + (2 \times 60,000) + (2 \times 60,000) = 50,000 + 70,000 + 120,000 + 120,000 = 360,000$
- Total Projected Cost (Rs.): $360,000 \times 12 = 4,320,000$
Revision Table: Key Project Estimation Concepts
| Term | Definition | How it's used here |
|---|---|---|
| Function Points (FP) | A unit of measurement for software size based on the functionality delivered to the user. | Given as the estimated size (864 FP). |
| Productivity | The rate at which work is completed, often measured in outputs per unit of effort (e.g., FP per person month). | Given as 12 FP/person month. Used to convert size (FP) to effort (person months). |
| Person Month | A unit of effort representing one person working for one month. | Calculated from FP and productivity (72 person months). This is the total effort needed regardless of team size or duration. |
| Project Duration | The total time taken to complete the project. | Calculated by distributing the total effort across the team size (72 person months / 6 persons = 12 months). |
| Project Cost | The total expenses incurred for the project, primarily labor costs in this scenario. | Calculated by multiplying the monthly team cost by the project duration. |
Additional Information: Software Cost Estimation Methods
Besides Function Point Analysis, several other methods are used for software cost estimation:
- Lines of Code (LOC): Estimates size based on the number of source code lines. Effort and cost models are built around LOC. However, LOC can be language-dependent and doesn't directly measure functionality.
- Algorithmic Cost Models: Use mathematical formulas based on various project attributes (size, complexity, team experience, etc.) to estimate effort and cost. COCOMO (Constructive Cost Model) is a famous example.
- Expert Judgment: Relying on the experience of senior developers, project managers, or domain experts to estimate cost. This can be quick but is subjective.
- Analogy: Estimating the cost of a new project by comparing it to similar completed projects. Requires good historical data.
- Bottom-Up Estimation: Breaking down the project into smaller tasks, estimating the cost for each task, and summing them up. This can be detailed but time-consuming.
Using Function Points provides a size metric that is independent of the programming language, focusing on the functionality from the user's perspective. This size metric is then used with historical productivity data to estimate the effort, which is finally translated into cost using labor rates.
Important Questions from Software Maintenance
When a software application is modified to remain functional and compatible after its underlying operating system is upgraded, this activity falls under which category of software maintenance?
Which one of the following is not typically provided by Source Code Management Software?
Statistical software quality assurance in software engineering involves _________
Software reliability is described with respect to
(A) Execution Time
(B) Calendar Time
(C) Clock Time
Choose the correct answer from the options given below:
Modifying the software by restructuring is called
