Early Function Points Method for Estimating Software Development Effort

Introduction

The Early Function Points method (a method for early prediction of the size of a future program) was proposed by Roberto Meli in 1997 (Italy), as shown in the works .

This method is notable in that the effort required to develop a project can be estimated at different levels of knowledge: from a superficial idea of how the program will work to a deeply detailed view of how the system works. The accuracy of the calculated values depends on the level of knowledge. With an approach based on detailed information about the system, the calculation will be more accurate and less subject to change in later stages of work on the project . In this example of calculating the effort of an IT project, the functions are used at the level of perception of the future project, so the calculations given are approximate and will be periodically revised as the project is developed.

The Early Function Points method involves estimating such objects as logical data elements, macrofunctions, functions, microfunctions and functional primitives .

Functional primitives are elementary processes that cannot be broken down further (input, output and query processes) [8-9].

Microfunctions are functional primitives (create, delete, update and retrieve) and data management functions.

Functions are functional primitives related to the operational needs of users.

Macrofunctions are functions related to the customer's system, to an entire application or to a part of it.

Logical data elements are a group of related data elements, classified into five levels of complexity: "low," "medium," "high," "complex," "very complex"

With a high level of knowledge about the future application, all of the listed objects are used. But for the example of a mobile application, ILF, EIF, EI, EO and EQ can be used. And the following algorithm should be followed:

• – study the subject area in as much detail as possible, identify the necessary functions and tasks, and detail them;
• – assign each function to its corresponding type (ILF, EIF, EI, EO, EQ);
• – assess the complexity of each function (low, medium, high);
• – calculate the total number of unadjusted function points;
• – calculate the effort for this project.

Initial data

Let us determine what functions our mobile application for a coffee shop, intended to automate orders, will have:

• – authorization of users and staff in the system;
• – adding/deleting/editing users (customers, staff);
• – adding/deleting/editing dishes and drinks in the menu;
• – viewing information about particular dishes or drinks.

The project tasks will include:

• – storing the menu and working with its components;
• – storing information about customers and staff.

All data needed for the application to work is stored in a database. The program's database includes the following tables (Table 1).

Table 1. Structure and composition of the databases

Calculating the effort for developing a software product for a coffee shop

The application will consist of the following windows:

• – application login;
• – registration in the application;
• – personal account;
• – main program window;
• – purchase and payment history;
• – menu;
• – information about a particular dish or drink.

Following the Early Function Points method used and the base tables of rank and complexity assessment of the Function Points method, we will compile a table of information characteristics for further calculation (Table 2).

Table 2. Initial data for the calculation

Using the data from Tables 2 and 3, we calculate the number of function points using formula (1):

, (1)

where Fi are the complexity adjustment factors, taking integer values from 0 to 5 depending on the complexity of implementing the corresponding characteristic of the project (Table 3).

Table 3. Values of the system parameters

The total value of the complexity adjustment factors (Σ Fi) turned out to be 44.

Using formula (1), we calculate the number of function points:

FP = 53 × (0.65 + 0.01 × 44) = 57.77.

The resulting FP estimate is converted to a LOC estimate V using the following formula (2):

V = Klang × FP, (2)

where Klang depends on the programming language used to implement the software.

The development of this software project will use the C# programming language with a programming language coefficient (Klang) equal to 53, so the calculation is as follows:

V = 53 × 57.77 = 3061.81 LOC.

Based on the calculated number of lines of code (V), we classify this program as organic software. Accordingly, we take the coefficients N1 = 3.2; N2 = 1.05 and N3 = 0.38 from Table 4.

Table 4. Coefficients N1, N2, N3

We calculate the nominal effort (without taking into account labor cost coefficients, cost factors and complexity) using formula (3):

(3)

where KSLOC (thousands of lines) = V / 1000, and the values of N1 and N2 are determined from Table 4.

According to the data obtained, the effort of creating the mobile application is:

The development time is calculated using formula (4):

(4)

Using formula (4), we obtain the time to create the mobile application:

tdev. = 2.5 × TN3 = 2.5 × 10.36^0.38 = 6.08 months.

Following the recommended rule for distributing project costs, 40-20-40:

• – analysis and design account for 40% of the costs (of which planning and system analysis take 5%);
• – coding takes 20%;
• – testing and debugging take 40%;

we obtain the time in months for developing the project (Table 5).

Table 5. Distribution of time costs

Based on the data obtained, we can state that developing the mobile application for the coffee shop will require about 11 developers, 3062 lines of code and 6.08 months to create this software project under the conditions listed. As development proceeds, the data obtained will change, but at the initial design stage we can already estimate the effort for this software in this way.

Thus, we carried out a calculation using the Early Function Points method, as a result of which we determined the duration of application development, the required number of lines of code and the required number of developers for this project [13-14], even though the calculations and derivations of the Early Function Points method used here relied on information about functions that was not detailed to the precision that can be achieved at later stages of the software project life cycle.

See also

• Project estimation methods:
  • Expert estimation
  • Analogy-based estimation
  • Use Case Points (UCP)
  • Function Points (FP)
  • Early Function Points (EFP)
  • Fast Function Points (EFP)
• [[b7772]]

See also

• 6.2 Functional points method (function points) - performance measurement