Function Point Example Numbers and Magic Formula

Function Point Analysis is an interesting software measurement method. It is a bottom-up method.

The benefits look to be very attractive: It measures what the user asks for, not how it is implemented. It is technology independent. It adds only 1% of management cost. It is repeatable with 10% accuracy. It works well with agile processes that are based on use cases.

An Example of Real Numbers

From an example presented by, here are some numbers of a small project involving a distributed Swing application with embedded database:

  • The project was estimated 400 FPs.
  • At completion, the measured FPs are 440.
  • It looks like the measurement covers only the development part. The test is done by the customer.
  • Two developers, used 540 hours. A 0.815 FPs/hour rate.
  • The real calendar duration is 10 weeks. Or a 0.55 FPs/hour calendar rate, translating to about 88 FP/SM (FP per man-month).
  • The developer charged a $250/FP rate.


Once a FP number is determined for a project, some magic formulae can further assist the planning of the work:

  • Project Duration = 2.5 * (Cube root of work months)
  • Optimum Staffing Size = Square root of work months
  • Project Duration = 0.75 * (Cube root of work month)


To gain accuracy with FP analysis, the customer, the type of application, the developers, the technology, etc, should stay the same. If any of them changes, the numbers should be re-aligned through experiments. A few notes about the technology change:

  • The author to the above example found web application is much much faster than Swing application.
  • Some statistics shows different programming languages have varying LOC/FP. This can be a guideline for choosing languages.

LOC/FP Statistics

This table from web site shows lines-of-code per function-point for some common languages:

     Language     QSM SLOC/FP Data
                  avg  median low   high
     Assembly     209   203   91    320
       C          148   107   22    704
       C++         59    53   20    178
       Java        55    53    9    214

     JavaScript    54    55   45     63
       ASP         56    50   32    106
       JSP         59     -    -      -
       Perl        57    57   45     60
       SQL         31    30   13     80
     SQL Forms     11    11   10     15
       HTML        43    42   35     53

As is evident from the table, choosing Java over C should have an increased productivity by a factor of two to five. Average three.

In comparison, the 4GL supports 12-20 FP/SM, or 16-27 LOC/FP. Compare to the 88 FP/SM number in the example above this seems low. Keep in mind the specific example is about analysis and development phases only.

Another industrial data table by Mayer Consulting shows statistics of more programming languages.

Application Types

Since FP counts data and file elements only, it may not apply to all types of applications. As a comment to this news on suggests, FP is all about client-server information systems. It breaks down on complex multi-tiere systems because it does not account for the quality goals of a system: performance, maintainability, robustness, etc.


About minghuasweblog

a long time coder
This entry was posted in All, Reading and tagged , , . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s