Skip to content

Estimation Techniques

Software estimation is the process of predicting the effort and cost required for development. It is characterized by high uncertainty in the early stages—where estimates can vary from 0.25× to 4× the actual effort—and becomes increasingly accurate as the project progresses through requirements, design, and coding.

Main Estimation Approaches

There are two primary ways to approach software estimation:

  • Experience-Based Estimation: This relies on a manager’s experience with past projects. Tasks are identified, estimated individually, and then summed, often through team discussions and spreadsheets.
  • Algorithmic Cost Modeling: This uses mathematical formulas to estimate effort based on software size, complexity, and team factors. These models are developed by analyzing data from completed projects to find formulas that match real-world costs.

Pasted image 20260420233747.png

The Basic Effort Formula

Most algorithmic models follow a standard formula to estimate effort (usually measured in person-months): $Effort = A \times Size^B \times M$

  • A: A constant determined by the organization and the specific type of project.
  • Size: Measured in Source Lines of Code (SLOC) or Function Points.
  • B (Exponent): Reflects system complexity, typically ranging from 1 to 1.5.
  • M (Multiplier): Represents product, team, and process factors, such as required reliability, team experience, and tool support.

Software Size Estimation

The most common size measure is Source Lines of Code

Size estimation can be done using previous experience, converting functional points to code size, estimating sizes of system components etc.

COCOMO II (Constructive Cost Model II)

COCOMO II is a modern version of the original 1981 model, updated to support iterative development, component-based systems, and rapid development techniques. It utilizes four submodels used at different stages:

  • Component-based development
  • Dynamic programming languages
  • Database programming
  • Rapid development techniques

It also supports iterative development models such as the Spiral Model.

  1. Application Composition Model: Used for prototyping or systems built with dynamic languages and database programming. Size is measured in Application Points (e.g., number of screens and reports). $$PM = (NAP * (1 - \%reuse)/100)/PROD$$
  2. Early Design Model: Used during early design stages based on Function Points converted into lines of code. It uses seven simplified cost multipliers, such as personnel capability (PERS), product reliability (RCPX), and platform difficulty (PDIF).
  3. Each factor is rated on a six-point scale (Very Low to Very High)
  4. Reuse Model: Specifically estimates the effort required to integrate reused or automatically generated code.
    • Black-box reuse (no modifications) is considered zero effort.
    • White-box reuse requires adaptation, which is converted into Equivalent Source Lines of Code (ESLOC).
    • For automatically generated code - $$(ASLOC * AT/100) / ATPROD$$
    • For Reused Components (ESLOC) - $$ESLOC = ASLOC * (1 - AT/100) * AAM$$
    • AAM includes Software Understanding and Adaption Factor
  5. Post-Architecture Model: The most detailed and accurate model, used after the system architecture is designed. It uses 17 cost drivers and considers five scale factors to determine the complexity exponent ($B$), including team cohesion, process maturity, and risk resolution.

  6. Estimation of SLOC - SLOC + ESLOC

  7. These models produce increasingly accurate estimates as the project progresses.

Estimating Project Duration

Beyond effort, the COCOMO model provides a formula to estimate the nominal calendar time ($TDEV$) required to complete a project: $TDEV = 3 \times (PM)^{(0.33 + 0.2 \times (B - 1.01))}$ In this formula, $PM$ is the effort computed by the model, and $B$ is the complexity-related exponent.