- About Us
- Web Sites
- Current Issues
- COURSES 16
- General Server Configuration
- Archived Sites
- Pre-Moodle 2
- 2010 Server Rollover
- COURSES 15
- Systems Group
- Data Portal
- Cert Exam App
- Data Updates
- EAHR Advising
- EPSY Grad Application
- Field-Based/Student Teaching
- Grad Review
- HLKN Advising Forms
- Project Achieve
- SPED Prof Phase App
- Student Database
- Student Observations
- Help System
- Windows Utilities
- Linux Utilities
- Hard Drive Data Recovery
- Data Portal Servers
- VM Hosts
- Shutdown Order
- Triplite KVM Switches
- IT Security
Function Points (FP) is a metric designed to measure "units of software" in terms of functionality. FP's remain constant regardless of who develops the software or language used.
Categories of FPs
Number of user inputs
- Each user input that provides distinct application oriented data to the software is counted.
Number of user outputs
- Each user output that provides application oriented information to the user is counted. In this context "output" refers to reports, screens, error messages, etc. Individual data items within a report are not counted separately.
Number of user inquiries
- An inquiry is defined as an on-line input that results in the generation of some immediate software response in the form of an on-line output. Each distinct inquiry is counted.
Number of files
- Each logical master file is counted.
Number of external interfaces
- All machine-readable interfaces that are used to transmit information to another system are counted.
Another way to group
- Internal Logical files (ILF) (e.g., database tables)
- External interface files (EIF)
- External Inputs (EI)
- External Outputs (EO)
- External Inquiries (EQ)
Internal Logical Files (ILF)
ILFs represent data that is stored and maintained within the boundary of the application you are counting. When counting ILFs you are basically counting the data functions that your application is being built to maintain.
Official Def'n. "An IFL is a user-identifiable group of logically related data or control information maintained within the boundary of the application. The primary intent of an ILF is to hold data maintained through one or more elementary processes of the application being counted."
Examples include ables in a DB, flat files, LDAP data stores.
Data Element Types (DETs)
2 - 5
L = low complexity, A = average complexity, H = high complexity
External Interface Files (EIFs)
EIFs represent the data that your application will use/reference, but data that is not maintained by your application.
Official Def'n. "An external interface file (EIF) is a user identifiable group of logically related data or control information referenced by the application, but maintained within the boundary of another application. The primary intent of an EIF is to hold data referenced through one or more elementary processes within the boundary of the application counted. This means an EIF counted for an application must be in an ILF in another application."
Count DETs and RETs as with ILF and use weighting table below to calculate FPs.
No. or Function Points
External Inputs (EI's)
Official Def'n. An external input (EI) is an elementary process that processes data or control information that comes from outside the application boundary. The primary intent of an EI is to maintain one or more ILFs and/or to alter the behavior of the system.
Examples of EIs include:
- Data entry by users.
- Data or file feeds by external applications.
Function point counts resulting from EI's
Allocating FPs to EIs is similar to the process we covered for ILFs and EIFs. However, in this case, instead of doing a lookup based on DET's and RET's to determine a Low/Average/High complexity, the lookup is performed using DET and FTR values. As you'll recall from the earlier definition, an FTR is a "file type referenced", so it can be either an ILF or an EIF.
As an example, suppose that you have a process that has 5 DET's, and during the processing it references an EIF named Users and an ILF named Process. You would go into the following table looking for the complexity of an EI that has 5 DET's and 2 FTR's. As you'll see from the table below, this EI is considered an "Average" complexity EI.
Data Element Types (DET's)
3 or more
Table 6: EI complexity matrix To carry our example forward, as you can see from the following table, an Average complexity EI is worth 4 FPs.
External Outputs (EO's)
Official Def'n. "An external output (EO) is an elementary process that sends data or control information outside the application boundary. The primary intent of an external output is to present information to a user through processing logic other than, or in addition to, the retrieval of data or control information. The processing logic must contain at least one mathematical formula or calculation, create derived data maintain one or more ILFs or alter the behavior of the system. "
EO examples include: Reports created by the application being counted, where the reports include derived information.
Function point counts resulting from EO's
Allocating FP's to EO's is very similar to the process for EI's. Again, you perform your lookup using DET's and FTR's, with a resulting Low/Average/High complexity.
As an example, suppose that you have a process that you've identified as being an EO, and it has 10 DET's and references two FTR's. You would go into the following table looking for the complexity of an EI that has 10 DET's and 2 FTR's. As you'll see from the table below, this EO is considered an ``Average complexity EO.
Data Element Types (DET)
4 or more
To carry our example forward, using the table that follows, you'll see that an Average complexity EO has a value of 5 FPs.
External Inquiries (EQ's)
Official Def'n. An external inquiry (EQ) is an elementary process that sends data or control information outside the application boundary. The primary intent of an external inquiry is to present information to a user through the retrieval of data or control information from an ILF of EIF. The processing logic contains no mathematical formulas or calculations, and creates no derived data. No ILF is maintained during the processing, nor is the behavior of the system altered.
Examples of EQs include:
- Reports created by the application being counted, where the report does not include any derived data.
- Other things known as "implied inquiries", which unfortunately, are a little out of scope for this paper.
Function point counts resulting from EQ's
Allocating an FP count to EQs is very similar to the process for EIs and EOs. Again, you perform your lookup using DETs and FTRs, with a resulting Low/Average/High complexity.
As an example, suppose that you have a process that you've identified as being an EQ, and it has 20 DETs and references 4 FTRs. You would go into the following table looking for the complexity of an EI that has 20 DETs and 4 FTRs. As you'll see from the table below, this EQ is considered a "High" complexity EQ.
Data Element Types (DETs)
4 or more
Carrying our EQ example forward, you'll find from the table below that a High complexity EQ is worth 6 FPs.
- Elementary process
- An elementary process is the smallest unit of activity that is meaningful to the user. An elementary process must be self-contained and leave the business of the application being counted in a consistent state.
- Data Element Type, or DET
- A data element type is a unique, user recognizable, non-repeated field. This definition applies to both analyses of data functions and transactional functions.
- Record Element Type, or RET
- A record element type is a user recognizable subgroup of data elements within an Internal Logical File or External Interface File.
- File Type Reference (FTR)
- relation to either a ILFs and EIF