AEFP Meeting #9. September 10 th 2015

Transcription

1 AEFP Meeting #9 September 10 th

2 Agenda 2 Introduction (5 min) Review and acknowledge of approach (20 min) Questions (15 min) Next steps (20 minutes)

3 Objective Effort on code modification Functional Framework development Technical Framework development Optimization Heavily used configuration (AETP) Technical Batch Multiple sites deployment Optimization (cache mechanism, data replication ) Technical Enhancement (AETP) Data Clean up Administration tasks Operational ease Disaster recovery process Modified Application Functional Size () Outcome Output Functional Enhancement (AEFP) Modified Vx Vx+1 Version

4 Definition (1) For the purpose of this specification, the following terms and definitions apply: : Named Source Code Computational Objects which can be called for execution. An artifact cannot include another artifact. Automated Enhancement Function Points (AEFP): which are subject to an enhancement (added, modified, or deleted) Automated Enhancement Technical Points (AETP): ATP which are subject to an enhancement (added, modifier, or deleted) Automated Function Points (): cf. OMG specifications; Software sizing measure value accounting for the features exposed to end-users and third-party applications by the software. Automated Function Point Data Entity: Source Code Computational Object which supports the implementation of data entities according to OMG specification Automated Function Point Transaction Entry Point: Source Code Computational Object which supports the interface with end users or third party applications and used in the OMG specification as starting points of code paths towards data entities Automated Function Point Transaction Implementation Scope ( Scope): Ensemble of Source Code Computational Objects which support the implementation of the Automated Function Point by the software Automated Function Point Transaction Implementation : List of which support the implementation of the Automated Function Point by the software, subset of the Scope Automated Technical Points (ATP): Software sizing measure value accounting for the components in the software that are not referenced by implementations. Automated Technical Points Implementation Scope (ATP Scope): Ensemble of Source Code Computational Objects which support the implementation of the software but none of the Automated Function Point. That is, ATP Scope is the complement of Scope with respect to the whole software. Automated Technical Points Implementation : List of which support the implementation of the software but none of the Automated Function Point, subset of the ATP Scope

5 Definition (2) Boundary: The boundary is a conceptual interface between the software and the users or third-party applications Complexity Factor (CF): value modifier, to compute AEFP value resulting from an evolution that involved a given complexity and that injected another given complexity, taking into account the amount of shared implementation components Effort Complexity (EC): Artifact complexity measure value accounting for the difficulty to evolve and therefore the required effort to do so, based on its size, comment level, algorithmic complexity, data access complexity, and coupling Equivalence Ratio (ER): Application- and release-specific conversion ratio, based on the size as measured with IP of the software implementation of the software as measure with FP Function Points (FP): cf. OMG specifications; Software sizing measure unit accounting for the exposed features functional weight, regardless of their technical implementation Function Points equivalent (FPeq): Software sizing measure unit estimating the functional weight of software ATP, based on their implementation size value expressed in IP, and based on ER average implementation size value required to implement the software. Implementation Points (IP): Software sizing measure unit accounting for the implementation of technical and functional components of the software. Source Code Computational Objects: Computational Objects of the source that can be detected during static analysis

6 Transaction definition The Application Model is produced by analyzing the source code of the application to be sized. It shall contain the static elements of the application that are used in both outcome and output measurement process. In addition to the code elements required to perform the functional size measurement according to the 1.0 specification document (chapter 6), the current specification also requires to 1. Build directed graphs representing the direct dependencies of several objects starting from the transactional entry points (not limited any more to the sole directed graphs connecting data elements and transactional entry points). 2. Identify all named code elements containing processing logic, that is, in the current document, within and outside of the directed graphs 3. Identify all named code elements containing processing logic, that is, in the current document, that are shared by multiple directed graphs transaction implementation scopes are directed graphs 1. starting from the software User Interface (or public API), 2. using field use, state change, method and function invocation, class inheritance and interface implementations dependency relationships (that is, dependencies as defined in 1.0 section 6.5), 3. ending with data functions, software boundary, or the absence of further dependency relationship. Contrary to 1.0 specification requirements for which the existence of at least one code path between the transaction entry points and the data functions were enough, the comprehensiveness of the content of these directed graphs matters and will impact measurement results.

7 Add-on on Structure of a transaction: A transaction is the aggregation of source code items which are called by a beginning of transaction and not only the items part of the critical path between the external interface and the logical file. External interface Artifact Logical file Composition of a transaction: Transaction artifacts, source code items with processing logic, will be used for following computations SQL Languages Visual Basic Language Function VB Event Procedure VB Function Package function VB Property Get Package VB Property Let procedure VB Property Set Trigger VB Sub View Java Language C/C++ Language Java Constructor C/C++ Function Java Method C/C++ Method Java Initializer C/C++ Constructor C/C++ Destructor MS.NET Languages Method Property Set Property Get AddOn RemoveOn Fire Constructor Destructor Event efunction esub epropertyget epropertyset epropertylet eevent efile Web Languages (JSP/ASP/JS) Method efunction esub emethod epropertyget epropertyset epropertylet eevent Java Method efile SAP ABAP ABAP Form ABAP Function ABAP Event Block ABAP Module ABAP Method ABAP Constructor ABAP Event Method ABAP File Level Code of custom programs, user-exits and includes ABAP Event WebDynpro Supply Function WebDynpro Event Handler WebDynpro Method Mainframe Cobol Program JCL Job JCL Procedure IMS Segment IMS DB PCB

8 #1 Generate the application model Approach: Step 1 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- Updated Unchanged

9 #1 Generate the application model Approach: Step 2 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- Updated Unchanged

10 #1 Generate the application model Approach: Step 3 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- Updated Unchanged scope

11 #1 Generate the application model Approach: Step 4 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- Updated Unchanged scope ATP scope

12 #1 Generate the application model Approach: Step 5 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- Updated Unchanged IP(ATP) IP()

13 #1 Generate the application model Approach: Step 6 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- Updated Unchanged IP(ATP) IP()

14 #1 Generate the application model Approach: Step 7 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- Updated Unchanged IP(AEFP) IP(ATP) IP()

15 #1 Generate the application model Approach: Step 8 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- AEFP AEFP Updated Unchanged IP(AEFP) IP(ATP) IP()

16 #1 Generate the application model Approach: Step 9 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- AEFP AEFP Updated Unchanged IP(AEFP) IP(ATP) IP(AETP) IP()

17 #1 Generate the application model Approach: Step 10 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- AEFP AEFP Updated Unchanged ER IP(AEFP) IP(ATP) IP(AETP) IP()

18 #1 Generate the application model Approach: Step 11 #5 Identify,, Shared & Compute Artifact Effort Complexity, IP()[, IP(ATP)] #9 Identify AETP scope & Compute IP(AETP) #2 Detect UI, Data, directed graph & compute #3 Identify implementation scopes #6 Identify, Updated, (using the application models of 2 revisions) #7 Identify, Updated, & Compute IP(AEFP), ECprocessed, ECvaration, #10 Compute ER from and IP() #11 Compute AETP[, ATP] from ER and IP(AETP)[, IP(ATP)] #4 Identify the ATP implementation scope #8 Compute AEFP Code element Shared Non- Non- AEFP AEFP ATP AETP Updated Unchanged ER ER IP(ATP) IP(AETP) IP(AEFP) IP()

19 Automated Enhancement Function Point (AEFP) New Transaction Updated Transaction Transaction AEFP ADDED = ADDED (LAST) x CF ADDED AEFP MODIFIED = MODIFIED (LAST) x CF MODIFIED AEFP DELETED = DELETED (BASE) x CF DELETED New transaction which can reuse some existing components (green) and some part of the application platform (white). Updated transaction which can be flag ged as updated as soon you have one updated components unless this comp onent is matching with exception list. transaction which can be flagg ed as deleted as soon at least the entr y point is deleted.

20 Complexity factor The complexity factor reflects the degree of change of each identified (data and transactional) function. The AEFP ADDED The AEFP DELETED The AEFP MODIFIED (Data Function) AEFP ADDED = ADDED (LAST) x CF ADDED AEFP DELETED= DELETED(BASE) x CF DELETED IMF = 1.00 IMF = 0.40 AEFP MODIFIED = MODIFIED (LAST) x CF MODIFIED Percentage change = (Number of DETs added/changed/deleted) / (Number of DETs in original data function ) * 100 Percentage DETs ⅓ (x 100%) ⅔ (x 100%) 100% > 100% Complexity factor (CF) Percentage change = (Number of DETs added/changed/deleted) / (Number of DETs in original data function ) * 100 If an EIF or an ILF that change type but do not change internally CF = If an EIF or an ILF is split the impact factor CF = If an EIF and an ILF are combined, the impact factor CF = 0.40

21 Complexity factor The AEFP MODIFIED (Transaction Function) AEFP MODIFIED = MODIFIED (LAST) x CF MODIFIED Complexity factor (CF) Evolved Effort Complexity Effort Complexity variation ⅓ (x 100%) ⅔ (x 100%) 100% > 100% ⅓ (x 100%) ⅔ (x 100%) % > 100% Evolved Effort Complexity = (Sum of effort complexity of added/changed/deleted artifacts in original) / (sum of complexity of artifacts in original ) Effort Complexity variation = ((sum of complexity of artifacts in latest) - (sum of complexity of artifacts in original)) / (sum of complexity of artifacts in original) If a transaction is flagged as modified only by shared components the CF is set at 0.25 If a transaction is flagged as modified by more than 75% of shared components versus unique modified artifact the CF is cap at 0.50 If a transaction is flagged as modified by more than 50% of shared components versus unique modified artifact the CF is cap at 0.75 The scope of the calculation of the complexity will include all artifacts of the transaction. Shared components will be consider as part of the scope of calculation of the modification. Technical components will also be considered as part of the calculation of the modification. Complexity processed at the component level (artifact) Component Complexity is a combination of (CC, SQL, Fan in, Fan out, Granularity, Documentation). A specific ratio will be apply per complexity / technology to provide an effort complexity.

22 Next Steps for CISQ 1. Official Acknowledgement by members today that the specification is ready for production 2. Produce AEFP specification with in OMG format expressed in OMG meta-models (KDM and SMM) 3. Submit the AEFP specification as a Request for Comment (RFC) to OMG by November 9 so it can be considered at OMG Technical Meeting in December

23 Actions for Sponsors Run scripts as soon as possible and submit the results to Philippe-Emmanuel these analyses will be important for validating the approach when we submit the RFC for consideration to OMG Obtain approval from your company by Oct 12: for you to be listed as a co-author of the specification for your company to be a submitter of the RFC to OMG Promote the importance of this measure for the future of productivity analysis inside your company 23