Software Estimation

This post is a introduction to software estimation.

This is reviewed in CSSTIAE topic 2022.99.

Software Estimation Methods

Estimation methods and models featured on this post:

Size-based
- LOC
- COCOMO
- 3-point estimation
- Delphi techniques
- Putnam Model
- Planning Poker
Functional
- UCP
- Function Point Methods
  - Albrecht’s FPA
  - Mark II FPA
  - COSMIC Function Points
  - IFPUG FPA
  - FiSMA
  - SiFP
  - 3D Function Points
Non-functional points
- Fuzzy Logic
- Standard Components
- Story Points
- T-SHIRT Sizing
- SNAP
- Staffing size

LOC

Lines of Code (LOC)

Measures the size of a software system by counting the number of lines of code.
Used to estimate effort, cost, and complexity.
Simple but lacks accuracy due to differences in coding styles and programming languages.

It can be considered a size estimation method.

COCOMO

COCOMO (Constructive Cost Model) is a widely used estimation model that predicts effort and cost based on project size and complexity.

UCP

Use case points (UCP) method uses a use case diagram as an input.

You can read this article about use case points.

Putnam Model

Putnam model (SLIM – Software Lifecycle Management Model).

Based on empirical research on software projects.
Uses a mathematical model to estimate effort, time, and cost based on staffing levels and historical data.
Suitable for large-scale projects with well-documented historical metrics.

It can be considered an effort estimation method.

Function Points

Function points:

IFPUG
COSMIC-FSM
NESMA
Mark-II
FiSMA

Albrecht’s FPA

Albrecht’s Function Point Analysis (FPA)

Developed by Allan Albrecht (IBM) to measure software functionality based on user interactions.
Estimates effort based on inputs, outputs, inquiries, internal files, and external interfaces.
More reliable than LOC for early estimations and cross-language comparisons.

It can be considered a functional estimation method.

It was presented in the paper “Measuring Application Development Productivity” by Allan J. Albrecht, that worked then for IBM, in 1979. You can read the paper on this external link.

IFPUG’s FPA

The International Function Point User Group (IFPUG) defines its own FPA technique. It was created in 1986, and it is one of the earliest FPA approaches.

Its standard is ISO 20296. The first version was ISO 20296:2009, and the latest version is ISO 20296:2023.

FPA at IFPUG website

NESMA FPA

The Netherlands Software Metrics Association (NESMA) created its own FPA in 1989. It is closely related to IFPUG FPA. This idea is supported by this external document.

NESMA examples

Mark-II FPA

Mark-II Function Point Analysis (Mk II FPA) is a different approach than

An improvement over Albrecht’s method, developed by Charles Symons.
Simplifies and refines function point counting, making it more accurate.
Frequently used in the UK and European industries.

It can be considered a functional estimation method.

Its standard is ISO/IEC 20968.

ISO/IEC 14143

It seems that there is an standard ISO/IEC 14143 with the title “Information technology – Software measurement – Functional size measurement”. It was originally issued in 1998.

Other standards seems to be implementations of ISO/IEC 14143.

COSMIC-FSM

The Common Software Measurement International Consortium (COSMIC) was created in 1998. It adapted the idea of IFPUG FPA to the new development trends.

COSMIC Function Size Measurement is an approach to functional sizing, considering software behavior and data movement.

You can read this post about COSMIC-FSM.

FiSMA

Finnish Software Measurement Association (FiSMA) evolves from IFPUG.

Staffing Size

Staffing size is a estimation method for object-oriented programming proposed in Métrica v3, a framework used in the public sector in Spain.

You can read this post about staffing size.