Intermediate Cocomo Example Calculation

Calculate software development effort, schedule, and cost using the Intermediate COCOMO model with 15 cost drivers.

Comprehensive Guide to Intermediate COCOMO Example Calculations

The Constructive Cost Model (COCOMO) is a procedural software cost estimation model developed by Barry Boehm that allows one to estimate the effort, schedule, and cost of developing software. The Intermediate COCOMO model extends the Basic COCOMO by incorporating 15 cost drivers that account for various project attributes affecting development effort.

Understanding the Intermediate COCOMO Model

The Intermediate COCOMO model uses the following formula to calculate effort in person-months:

Effort = a × (KLOC)^b × EAF

Where:

• KLOC = Thousand Lines of Code
• a = Coefficient that depends on the development mode (Organic, Semi-Detached, Embedded)
• b = Exponent that depends on the development mode
• EAF = Effort Adjustment Factor (product of all cost driver multipliers)

Development Modes and Their Parameters

Development Mode	Description	a (Coefficient)	b (Exponent)
Organic	Relatively small, simple projects with small teams working in a familiar environment	2.4	1.05
Semi-Detached	Intermediate projects with mixed experience levels and some unfamiliar aspects	3.0	1.12
Embedded	Complex projects with tight constraints and high innovation requirements	3.6	1.20

The 15 Cost Drivers in Intermediate COCOMO

The Intermediate COCOMO model incorporates 15 cost drivers categorized into four groups:

1. Product Attributes:
   • RELY – Required Software Reliability
   • DATA – Database Size
   • CPLX – Product Complexity
2. Computer Attributes:
   • TIME – Execution Time Constraint
   • STOR – Main Storage Constraint
   • VIRT – Virtual Machine Volatility
   • TURN – Computer Turnaround Time
3. Personnel Attributes:
   • ACAP – Analyst Capability
   • AEXP – Applications Experience
   • PCAP – Programmer Capability
   • VEXP – Virtual Machine Experience
   • LEXP – Programming Language Experience
4. Project Attributes:
   • MODP – Modern Programming Practices
   • TOOL – Use of Software Tools
   • SCED – Required Development Schedule

Step-by-Step Calculation Process

To perform an Intermediate COCOMO calculation:

1. Estimate Lines of Code (LOC): Determine the estimated size of the software product in thousands of lines of code (KLOC).
2. Select Development Mode: Choose the appropriate development mode based on project characteristics.
3. Assess Cost Drivers: Evaluate each of the 15 cost drivers and select the appropriate multiplier for each.
4. Calculate EAF: Multiply all the cost driver values to get the Effort Adjustment Factor (EAF).
5. Calculate Effort: Apply the COCOMO formula using the selected mode parameters and calculated EAF.
6. Calculate Development Time: Use the effort calculation to determine the development schedule.
7. Calculate Staffing: Determine the average number of personnel required.
8. Calculate Cost: Multiply the effort by the average developer salary to get the total project cost.

Practical Example Calculation

Let’s walk through a practical example using the calculator above:

1. Project Parameters:
   • Lines of Code: 50,000 (50 KLOC)
   • Development Mode: Semi-Detached
   • Average Salary: $90,000/year
2. Cost Drivers (all set to nominal = 1.00 for this example):
   • RELY = 1.00
   • DATA = 1.00
   • CPLX = 1.00
   • TIME = 1.00
   • STOR = 1.00
   • VIRT = 1.00
   • TURN = 1.00
   • ACAP = 1.00
   • AEXP = 1.00
   • PCAP = 1.00
   • VEXP = 1.00
   • LEXP = 1.00
   • MODP = 1.00
   • TOOL = 1.00
   • SCED = 1.00
3. Calculations:
   • EAF = 1.00 (product of all cost drivers)
   • Effort = 3.0 × (50)^1.12 × 1.00 = 3.0 × 74.98 × 1.00 = 224.94 person-months
   • Development Time = 2.5 × (224.94)^0.35 = 14.65 months
   • Average Staffing = 224.94 / 14.65 = 15.35 people
   • Productivity = 50,000 / 224.94 = 222 LOC/person-month
   • Total Cost = (224.94 × $90,000) / 12 = $1,687,050

Interpreting the Results

The Intermediate COCOMO calculation provides several important metrics:

• Effort (Person-Months): The total amount of work required to complete the project, expressed in person-months. This helps in understanding the overall workload.
• Development Time (Months): The estimated calendar time required to complete the project. This is crucial for project scheduling and timeline planning.
• Average Staffing: The average number of people needed throughout the project. This helps in resource allocation and team sizing.
• Productivity: The number of lines of code produced per person-month. This metric can be used to compare against industry benchmarks.
• Total Cost: The estimated financial cost of the project based on the effort and average salary. This is essential for budgeting purposes.

Comparative Analysis of COCOMO Models

Feature	Basic COCOMO	Intermediate COCOMO	COCOMO II
Complexity	Low	Medium	High
Cost Drivers	None	15	17+ (with scale factors)
Accuracy	Rough estimate (±30%)	Better estimate (±20%)	Most accurate (±10-15%)
Development Phases	Single phase	Single phase	Multiple phases
Best For	Quick estimates	Detailed project planning	Modern software development

Common Challenges in COCOMO Application

While COCOMO is a powerful estimation tool, practitioners often face several challenges:

1. Accurate LOC Estimation: Lines of code can be difficult to estimate accurately in the early stages of a project, especially with modern development practices that emphasize code reuse and frameworks.
2. Subjective Cost Drivers: Many cost drivers are subjective and require expert judgment, which can introduce bias into the estimates.
3. Changing Requirements: Software projects often experience requirement changes, which can make initial COCOMO estimates less accurate over time.
4. Team Experience Variability: The model assumes consistent team experience levels, which may not reflect reality in many organizations.
5. Modern Development Practices: Agile methodologies and modern tools can significantly impact productivity in ways not fully captured by traditional COCOMO.

Best Practices for Effective COCOMO Usage

To maximize the effectiveness of COCOMO estimations:

• Calibrate with Historical Data: Adjust COCOMO parameters based on your organization’s historical project data for more accurate estimates.
• Use Expert Judgment: Involve experienced developers and project managers in assessing cost drivers to improve accuracy.
• Combine with Other Methods: Use COCOMO in conjunction with other estimation techniques like function point analysis for cross-validation.
• Update Estimates Regularly: Revisit and update COCOMO estimates as the project progresses and more information becomes available.
• Consider COCOMO II: For modern software development, consider using COCOMO II which accounts for newer development practices and technologies.
• Document Assumptions: Clearly document all assumptions made during the estimation process for future reference and learning.

Academic Research and Validation

The COCOMO model has been extensively studied and validated in academic research. Several studies have examined its accuracy and applicability:

• A study by the University of Southern California (Boehm’s institution) found that COCOMO estimates were within 20% of actuals for 68% of projects when properly calibrated (USC COCOMO Research).
• Research published in the IEEE Transactions on Software Engineering showed that Intermediate COCOMO provided better accuracy than Basic COCOMO for medium-sized projects, with a mean magnitude of relative error (MMRE) of 0.26 compared to 0.38.
• The Software Engineering Institute at Carnegie Mellon University has conducted comparative studies showing that COCOMO performs particularly well for government and defense software projects (SEI COCOMO Studies).

Industry Adoption and Case Studies

Intermediate COCOMO has been widely adopted across various industries:

• Defense: Used extensively by the U.S. Department of Defense for large-scale software projects, with documented cases showing 15-20% improvement in estimation accuracy.
• Aerospace: NASA and major aerospace contractors use COCOMO variants for mission-critical software development, where the model’s emphasis on reliability factors is particularly valuable.
• Finance: Large banks and financial institutions use Intermediate COCOMO for core banking system development, appreciating its balance between simplicity and detail.
• Telecommunications: Telecom companies have successfully applied COCOMO to network management software projects, often customizing the cost drivers for their specific domain.

Limitations and Criticisms

While COCOMO is widely respected, it’s important to understand its limitations:

1. LOC Dependency: The model’s reliance on lines of code as the primary size metric is criticized as outdated in an era of model-driven development and code generation.
2. Early Stage Limitations: COCOMO requires relatively detailed information about the project, making it less suitable for very early, high-level estimates.
3. Team Size Assumptions: The model assumes that adding more people will linearly increase productivity, which isn’t always true in practice (Brooks’ Law).
4. Technological Changes: The original COCOMO parameters were developed in the 1980s and may not fully account for modern development tools and practices.
5. Cultural Factors: The model doesn’t explicitly account for organizational culture, which can significantly impact productivity.

Alternatives and Complements to COCOMO

Several other estimation models can be used alongside or instead of COCOMO:

• Function Point Analysis: Measures software size based on functionality rather than code, which can be more stable early in the development process.
• COCOMO II: An updated version that addresses many of the original COCOMO’s limitations, including better support for modern development practices.
• SLIM: Software Lifecycle Management model that uses a different mathematical approach based on Putnam’s software equation.
• Use Case Points: An object-oriented estimation technique that counts use cases, actors, and technical factors.
• Agile Estimation: Techniques like story points and velocity tracking used in agile methodologies.
• Parametric Models: Commercial tools like SEER-SEM or TruePlanning that offer sophisticated parametric estimation capabilities.

Future Directions in Software Estimation

The field of software estimation continues to evolve with several promising directions:

1. Machine Learning Approaches: Research is exploring the use of machine learning to analyze historical project data and generate more accurate estimates.
2. Hybrid Models: Combining traditional models like COCOMO with newer techniques to leverage their respective strengths.
3. Continuous Estimation: Moving from one-time estimates to continuous estimation that updates as the project progresses.
4. Uncertainty Modeling: Better techniques for representing and communicating the uncertainty inherent in software estimates.
5. Domain-Specific Calibration: Developing specialized versions of estimation models tailored to specific industries or application domains.
6. Integration with DevOps: Incorporating estimation into continuous delivery pipelines for more responsive planning.

Conclusion and Practical Recommendations

The Intermediate COCOMO model remains a valuable tool for software project estimation, particularly for medium-sized projects where its balance between simplicity and detail provides useful insights. When using COCOMO:

• Start with the most accurate LOC estimate possible, considering your development approach
• Carefully evaluate each cost driver with input from experienced team members
• Remember that estimates are just that – estimates – and should be treated as ranges rather than exact numbers
• Combine COCOMO with other estimation techniques for cross-validation
• Update your estimates regularly as the project progresses and more information becomes available
• Consider using COCOMO II for modern development projects
• Document your estimation process and actual results to improve future estimates

For organizations serious about improving their estimation capabilities, investing in historical data collection and model calibration can significantly enhance the accuracy of COCOMO-based estimates. The National Institute of Standards and Technology (NIST) provides valuable resources on software measurement and estimation practices (NIST Software Metrics).

Ultimately, while no estimation model can predict the future with certainty, tools like Intermediate COCOMO provide a structured approach to software project planning that, when used thoughtfully, can significantly improve project outcomes.