Enhancement node - Right hand panel
The Enhancement node has been designed in response to a specific issue. Please read below to find out more information.
Each node contains a list of snapshots (Upper left panel) and a list of all objects present in the selected snapshot (Upper right panel) allowing you to understand why certain items have been marked as modified/added/deleted between snapshots. The Enhancement feature will identify all the objects that form each item (displayed in the Lower panel) and between how many items each object is shared (only available for Transactional Functions: a Transactional Function can belong to more than one "item" - see the Shared Counter option below). Once the object identification is complete you can then decide whether an object or objects should be included or excluded in the checksum value calculation for all items (Data Functions/Transactional Functions). When you have included or excluded an object from the checksum value calculation, you can then re-calculate (using the Recompute checksums and snapshot statuses option) all checksums for all items and all snapshots. The metrics (in particular the modified function points metric) are then also re-calculated based on the new checksum values and will be redisplayed in the Upper left panel allowing you to check whether the value is more in line with expectations.
CAST AIP uses two distinct measures to calculate enhancement Functions Points - these can be chosen when you generate a snapshot with the CAST Management Studio:
OMG Automated Enhancement Points (AEP)
Note that this measure is used by default from CAST AIP 8.2.x onwards.
CAST integrates the estimation of OMG Automated Enhancement Points (AEP). Like EFP, the feature helps to evaluate overtime the size of evolutions implemented by teams producing applications. It computes and displays data functions and transactional functions that have been modified, added, or deleted, and information on the technical components of applications that do not belong to any transaction. The unadjusted function points that are calculated are weighted with Complexity Factors based on the objects complexity.
The AEP measure considers both the functional and the technical sides of the application enhancement. Therefore, the computation of Automated Enhancement Points (AEP) is divided in two sections: Automated Enhancement Function Points (AEFP) and Automated Enhancement Technical Points (AETP). The total AEP will be the addition of these two: AEP = AEFP + AETP.
The total value of Automated Enhancement Function Points (AEFP) is calculated by adding the AEFP value of all Transactional Functions and Data Functions in the application. The AEFP of each individual Transactional Function / Data Function is calculated by multiplying its FP value by its Complexity Factor (AEFP = FP x CF). The Complexity Factor of a certain Transactional Function / Data Function is an adjustment factor (defined by an OMG-specification) which is calculated based on its status (added / modified / deleted) and the complexity of the objects inside the Transactional Function / Data Function.
NOTE: the value reported for AEFP includes only added, modified and deleted Functions. All unchanged Functions are automatically excluded from this value (their Complexity Factor is considered as 0, and thus their AEFP value will also be 0).
Automated Enhancement Technical Points calculation considers all technical objects in the application, i.e. those computational elements which are not the Automated Enhancement Function Point scope.
OMG Enhancement Function Points (EFP)
In addition to AEP, CAST also integrates the estimation of Enhancement Function Points (EFP) also called Project Function Points, so that CAST provides both baselining, e.g sizing an entire application using Automated Function Points and Enhancement Function Points. With the Enhancement Function Points feature, CAST AIP is in a position to display detailed information about the changes between two versions of an application and between two snapshots of the same application.
- Added FPs: FPs identified from the functions identified as created in the Vn+1 (i.e. that is added by the enhancement project)
- Modified FPs: FPs counted because existing function is changed during the enhancement project
- Deleted FPs: function points counted for function deleted during the enhancement project.
Differences between the two measures
The main differences between the legacy Enhancement Function Points (EFP) mode and the Automated Enhancement Points (AEP) mode (introduced in CAST AIP 8.2) are as follows:
- EFP does not consider the technical side of the application evolution; AEP does (calculating Automated Enhancement Technical Points, AETP)
- EFP uses a transaction reduced call graph (from Entry Points to End Points / Data Entities); whereas AEP considers the transaction full call graph (it covers also the paths that do not reach an End Point / Data Entity). This means that the number of objects in the transaction call graph for AEP is higher.
- The adjustment factor used to calculate Enhancement Function Points (EFP) is called "Impact Factor", and it is based on fixed user-defined formulas; on the contrary, the adjustment factor to calculate Automated Enhancement Function Points is called "Complexity Factor", and it is based on dynamic OMG-defined formulas.
The table below summarizes these differences:
|Mode||Transaction Call Graph||Adjustment Factor||Evolution|
|EFP||Reduced||Impact Factor (fixed user-defined formula)||Only Functional|
|AEP||Full||Complexity Factor (dynamic|
|formula)||Functional and Technical|
Note about switching between measurement modes
When changing the measurement mode it is important to take into consideration the impact this will have on the analysis/snapshot results and that it will introduce a disruption into the measurement trending. There are important differences between the two measures (AEP and EFP) that must be understood:
By default the data for the most recent snapshot will be displayed when the node is selected. If there is only one snapshot present for the selected Application, then data will show Added Function Points for both Transactional Functions and Data Functions. When more than one snapshot is present, the data show is a comparison between the current and previous snapshot. In this case, you may see Modified and Deleted Function Point data as well as Added.
Display with EFP measure
Display with AEP measure
Note about Automated Enhancement Technical Points (AETP)
AETP is the count of added / modified / deleted technical points, which are calculated based on the added / modified / deleted technical objects (i.e. objects which are not part of any transaction). In other words, AETP summarize the evolution performed in the application, but outside the functional scope (these objects are not taken into account in the functional points, so the new AEP measure introduces the concept of "technical points" to assess the enhancement done in these types of objects).
AETP data is not available when the EFP measure has been used to calculate the snapshot.
Prev. / Next buttons
It is possible to see data from a previous/next snapshot by clicking the Previous or Next buttons - data in the panel will refresh automatically.
Display AEP Detail
The formula used to generate AEP information are complex and use a variety of intermediary metrics. To help understand how AEP is generated, clicking the Display AEP Detail button will display these intermediary metrics and formula in a text file. You can find out more about this text file in Enhancement node - AEP Details.
Export List of Objects
This button can be used to export the list of technical objects that are involved in the Automated Enhancement Technical Points (AETP) calculation for a given snapshot (note that this feature will be available only for the snapshots computed using AEP measure). The output CSV file will contain the following values:
OBJECT_ID: Object ID
OBJECT_FULLNAME: Full name
OBJECT_TYPE_STR: Type of object
STATUS: Status in the current snapshot
EFFORT_COMPLEXITY: Effort Complexity
- RULE: Objects that have been captured through a set
- MANUAL: Objects that have been manually excluded
Warning: these values are not necessarily the same as the ones displayed in the AFP Calibration node. This node displays the AFP values at the present time, and they can suffer variations if you perform calibration actions and click on the Compute Function Points button. On the contrary, the values displayed in the Enhancement node are the definite AFP values that were computed for the application at the moment when a snapshot was executed. These values cannot be changed.
This section provides information about the elements that comprise the current Applications and snapshot:
|Number of Artifacts||Total number of artifacts in the Application.|
|Number of classes/programs||The number of main objects (classes and/or programs) in the Application.|
|Number of Objects||The number of all objects in the Application.|
|TFP/DFP||This is the ratio between Transactional Function points and Data-Function points.|
|Percentage of artifacts involved in TF||The ratio of the distinct number of artifacts in all Transactional Functions in the application compared to the total number of artifacts in the Application.|
|Average AFP per class/program||This to see if the size of the functional part (AFP) of the Application is relevant or not compared to the number of main objects (classes and/or programs).|
|Percentage of objects involved in TF||The percentage of the objects in the Application involved in Transactional Functions.|