Mar. 28, 2016
This topic provides an introduction to the use of the Effort Calculator variables in your Forward Path scenario. This topic uses an example to introduce the use of these features.
Effort Calculator estimates the cost and effort involved in remediating your application portfolio for a target platform (represented by one of the AppDNA reports). The calculation uses two main types of variables:
Using this information Effort Calculator estimates the expected cost of migrating the entire application portfolio to the new platform. You can now use these variables in your Forward Path scenario – for example, to estimate the cost of remediating each application. This topic provides a relatively simple example of how to do this. One of the sample scenarios that comes with AppDNA provides a more complex and sophisticated example.
For detailed information about the Effort Calculator variables and how they are used, see Effort Calculator.
You can access the user-defined Effort Calculator variables through the EffortCalculatorSettings object, which you retrieve through the Host object. The Host object is implicitly available to the entire scenario script. Here is a snippet that retrieves the EffortCalculatorSettings object for the Windows 7 report:
Private Dim vars As EffortCalculatorSettings ' Get the Windows 7 Effort Calculator settings object. vars = Host.GetEffortCalculatorSettings("Win7Module")
Notice that we have used the Windows 7 internal report identifier to retrieve the Effort Calculator variables for Windows 7. For a list of the report identifiers, see Create links to remediation report views.
You can see all of the properties of the EffortCalculatorSettings object in the Property Explorer on the right side of the Forward Path Logic Editor screen. The names of the properties closely relate to the text shown for the variables in the Effort Calculator screen. For example, the AppStagingHours property corresponds to the Staging time variable in the Staffing variables section of the Effort Calculator screen. We will use this variable in the example that follows.
It is possible to set the values of these variables in your scenario for use in that scenario, like this:
vars.TesterStagerCostPerDay = 23
To illustrate how to use the two types of Effort Calculator variables to calculate the estimated costs of remediating applications in your Forward Path scenario, we will walk through an example scenario. We will build it up in stages, in an attempt to make it easy to understand.
Here is a screenshot of the output the example creates:
AppDNA includes a Forward Path scenario function called Initialize(). If present in the scenario, AppDNA automatically calls this at the start of the processing. We will use this to initialize variables that we will use later in the scenario. For more information about the Initialize() function, see Grouped Forward Path reports.
Before the Initialize() function, we declare some variables that we will use throughout the script.
' Declare variables for use throughout the script. Private Dim vars As EffortCalculatorSettings Private Dim testingPerHour As Decimal = 0 Private Dim remediationPerHour As Decimal = 0
Here is the Initialize() function:
Public Overrides Sub Initialize() ' Get the Windows 7 Effort Calculator settings object. vars = Host.GetEffortCalculatorSettings("Win7Module") ' Calculate the testing and remediation cost per hour. testingPerHour = vars.TesterStagerCostPerDay / _ vars.NormalAppTestingHours remediationPerHour = vars.RemediatorCostPerDay / _ vars.NormalAppTestingHours ' Sort the report in descending order of cost. Settings.ApplicationSortBy = "Cost" Settings.ApplicationSortDescending = true End Sub
Notice that we are calculating the hourly testing and remediation costs. We do this by dividing the values stored in the variables that represent the tester or remediator cost per day by the value stored in the normal number of working hours in a day variable.
At the end of the Initialize() function, we set the sort order to be in descending order of the values in the Cost column. In this column we will display the calculated cost of remediating the application and staging it for UAT.
Here is the main ForwardPath() function. AppDNA automatically calls this once for every application that is selected when you run the report. Explanatory notes follow the example.
Public Function ForwardPath(ByVal currentApplication _ As Application) As Output Dim result As New Output() ' We will use three custom columns. result.CustomField1.Name = "Application Complexity" result.CustomField2.Name = "Action RAG" result.CustomField2.Value = _ currentApplication.Modules.Windows7.ActionRAG result.CustomField3.Name = "Action Complexity" ' Set the culture on the Cost column to US English, ' so that the US dollar currency symbol is used. result.Display.Cost.Culture = "en-US" ' Test the application's main RAG status, because ' the remediation depends on this. Select Case currentApplication.Modules.Windows7.RAG Case Rag.Green ' The RAG is green, so no remediation is necessary ' and the application can be staged for UAT. result.Outcome = "Stage UAT" result.RAG = RAG.Green ' No remediation is required, so the cost is of ' the staging only. result.Cost = testingPerHour * vars.AppStagingHours result.CustomField3.Value = "--" ' Convert the unfriendly application complexity ' "RAG" to a text. Select Case currentApplication.Complexity Case RAG.Red result.CustomField1.Value = "Complex" Case RAG.Amber result.CustomField1.Value = "Medium" Case RAG.Green result.CustomField1.Value = "Simple" End Select Case Rag.Amber ' The RAG is amber, so the application needs ' remediation. result.RAG = RAG.Amber result.Outcome = "Remediate" ' The cost calculation is more complicated, ' so we will do it in a separate "GetCost()" ' function. result.Cost = GetCost(currentApplication, result) Case Rag.Red ' The RAG is red - we need to check the action ' RAG to see if remdiation is possible. result.RAG = RAG.Red ' If the action RAG is red, the application ' cannot be remediated. If (currentApplication.Modules.Windows7.ActionRAG = _ RAG.Red) Then result.Outcome = "Redevelop" result.CustomField3.Value = "Hard" ' Convert the unfriendly application complexity ' "RAG" to a text and set an arbitrary ' replacement/redevelopment cost. Select Case currentApplication.Complexity Case RAG.Red result.CustomField1.Value = "Complex" result.Cost = 3000 Case RAG.Amber result.CustomField1.Value = "Medium" result.Cost = 2000 Case RAG.Green result.CustomField1.Value = "Simple" result.Cost = 1000 End Select ' The action RAG is not red, so remediation is ' possible. Else result.Outcome = "Remediate" result.Cost = GetCost(currentApplication, result) End If Case Else ' Catch all for applications that have not been ' analyzed or that are locked. result.Outcome = "Unknown" result.RAG = RAG.Unknown result.CustomField1.Value = "--" result.CustomField3.Value = "--" result.Cost = 0 End Select result.Display.SourcePath.Visible = false ForwardPath = result End Function
Notice that this function starts by setting up three custom columns (called CustomFieldn) – these are the three right-most columns in the screenshot of the output above. We use these as follows:
|CustomField1||The application complexity. Forward Path stores this as a red/amber/green "RAG". We translate these values into Complex/Medium/Simple texts in the script.|
|CustomField2||The application's action RAG. We get the value using the Application.Modules.Windows7.ActionRAG property.|
|CustomField3||The complexity/difficulty of the application's remediation action. We will retrieve the value for this column later in the script.|
The Cost column is automatically displayed in currency format. By default, Forward Path uses the currency symbol for the regional settings on the user's computer. In an international environment, this means that the currency symbol may vary depending on the settings on the device of the person viewing the report. (For example, it might display the euro sign for a user in France, the UK pound sign for a user in England, and the US dollar sign for a user in the United States.) In this example, we will therefore specify the US dollar symbol so that this will always be displayed regardless of the user's regional settings. To do this, we set the Culture property on the Cost column to "en-US", which indicates the United States.
The main body of the function consists of a Select Case statement that tests the application's Windows 7 RAG status and provides different processing depending on that status. Let's look at how we handle each value:
Here is the GetCost() function, which we called in the main function to calculate the remediation costs of amber applications and red ones that can be remediated. Explanatory notes follow the example.
Private Function GetCost(app As Application, _ cols As Output) As Decimal Dim remediationCost As Decimal = 0 Dim testingCost As Decimal = 0 ' 1. Using the triggered algorithms, get the ' algorithm with the hardest action. We will use this ' in our calculations. Dim maxAlgorithm As TriggeredRule = _ (From r in app.TriggeredRules _ Where r.ModuleIdentifier = "Win7Module" _ Where r.Action.Complexity = ActionComplexity.Hard Or _ r.Action.Complexity = ActionComplexity.Medium Or _ r.Action.Complexity = ActionComplexity.Easy _ Order By r.Action.Complexity Descending _ Select r).FirstOrDefault() ' 2. Display the algorithm's action complexity. cols.CustomField3.Value = maxAlgorithm.Action.Complexity ' 3. The remediation cost depends on the application ' complexity. Select Case app.Complexity ' A complex application. Case RAG.Red cols.CustomField1.Value = "Complex" ' The remediation cost also depends on ' the complexity of the action. So we will ' calculate the time based on the number of ' hours held in the Effort Calculator matrix. Select Case maxAlgorithm.Action.Complexity Case ActionComplexity.Easy remediationCost = remediationPerHour * _ vars.ComplexAppEasyRemediationHours Case ActionComplexity.Medium remediationCost = remediationPerHour * _ vars.ComplexAppMediumRemediationHours Case ActionComplexity.Hard remediationCost = remediationPerHour * _ vars.ComplexAppHardRemediationHours Case Else remediationCost = remediationPerHour * _ vars.ComplexAppMediumRemediationHours End Select If app.Modules.Windows7.ActionRAG = RAG.Amber Then ' Add the additional post-remediation testing ' because the application has an amber action RAG. testingCost = testingPerHour * _ vars.ComplexAppTestingHours End If ' A medium-complexity application. Case RAG.Amber cols.CustomField1.Value = "Medium" Select Case maxAlgorithm.Action.Complexity Case ActionComplexity.Easy remediationCost = remediationPerHour * _ vars.NormalAppEasyRemediationHours Case ActionComplexity.Medium remediationCost = remediationPerHour * _ vars.NormalAppMediumRemediationHours Case ActionComplexity.Hard remediationCost = remediationPerHour * _ vars.NormalAppHardRemediationHours Case Else remediationCost = remediationPerHour * _ vars.NormalAppMediumRemediationHours End Select If app.Modules.Windows7.ActionRAG = RAG.Amber Then ' Add the additional post-remediation testing ' because the application has an amber action RAG. testingCost = testingPerHour * _ vars.NormalAppTestingHours End If ' A simple application. Case RAG.Green cols.CustomField1.Value = "Simple" Select Case maxAlgorithm.Action.Complexity Case ActionComplexity.Easy remediationCost = remediationPerHour * _ vars.SimpleAppEasyRemediationHours Case ActionComplexity.Medium remediationCost = remediationPerHour * _ vars.SimpleAppMediumRemediationHours Case ActionComplexity.Hard remediationCost = remediationPerHour * _ vars.SimpleAppHardRemediationHours Case Else remediationCost = remediationPerHour * _ vars.SimpleAppMediumRemediationHours End Select If app.Modules.Windows7.ActionRAG = RAG.Amber Then ' Add the additional post-remediation testing ' because the application has an amber action RAG. testingCost = testingPerHour * _ vars.SimpleAppTestingHours End If End Select ' 4. Add the remediation and testing costs, ' and the cost of staging for UAT. GetCost = remediationCost + testingCost + _ (testingPerHour * vars.AppStagingHours) End Function
The following notes relate to the numbers in the comments in the above example:
1. We use the current application's Windows 7 TriggeredRules property. This property is a collection of TriggeredRule objects, which represent all of the algorithms that the application triggered during analysis for Windows 7. From this collection, we get the algorithm that has the hardest remediation action. We will use this to calculate the cost of remediating the application.
2. We display the complexity (difficulty) of the algorithm's remediation action in CustomField3.
3. We then use a Select Case statement again to test the application's complexity. We will provide different processing for each complexity. Let's look at how we handle a complex application:
The code for medium-complexity and simple applications mirrors the code for the complex application, but each time we select the Effort Calculator variables for medium and simple applications, respectively.
4. Finally, we add the remediation and testing costs we calculated to the cost of staging the application for UAT and set this into the return value.
For an example that calculates the remediation costs by taking into account the actions associated with all of the algorithms triggered by the application, see the sample scenario that comes with AppDNA.