Our Products

Software Migrations Ltd.  (SML) are a company that has been at the forefront of the automated comprehension and migration of Assembler Language Programs for the last 30 years.

Our FermaT toolset is based on Formal Methods and the use of Infinitary First Order Logic. The underlying mathematics has been peer-reviewed at least fifty times over the years and verified in every case. These mathematics and their application within the FermaT toolset guarantee that the code produced is functionally equivalent to the original Assembler code. This includes our own Wide Spectrum Language (WSL)  Pseudocode, Cobol, C or Java.

IMDFA

IMDFA – Inter-Module Data Flow Analysis is the latest development to help with business rules and data recovery. It shows how to follow a transaction from terminal command down to individual modules and also how the data moves through that path. It also shows how to go from a specific module to the commands that could invoke that module

IMDFA –  Full WPXX Call Graph

From entering Initial Module WPXX, IMDFA shows which modules are possibly involved. To get an accurate representation of a command we need to resolve all module calls possible by invoking that command, the following represents modules called by a typical TPF command. There are 2300 modules in this example and to fully resolve this network takes 2 billion operations. We then provide a way for the analyst to use this information to aid comprehension and move around the modules in the network

We can provide a path from a terminal command showing modules called using filters to make the result set more manageable.

In this example, we have a terminal command and we show the initial module invoked then the list of possible modules.

This example shows the call graph for WGXX from WPXX Branch 0, which is the shortest path between the 2 modules for WGXX from WPXX.

The Red box is the start of the path and the Blue box is the destination the Gold path is the direct flow from Red to Blue.

This example shows the call graph for WGXX from WPXX Branch 1. The Red box is the start of the path and the Blue box is the destination the Gold path is the direct flow from Red to Blue.

Right Clicking a module in the Call Graphs will allow the user to see the Transaction Information PopUp.

Each (i) icon is clickable to show more details in a secondary PopUp.

Semantic Slicing

The ability to identify a specific business transaction path through modules making analysis focussed only on the code that needs to be analysed for that specific business transaction – this reduces the analysis effort significantly

  • Sheer Volume of code to review can be a major challenge in Assembler and TPF migration projects
  • Semantic slicing allows us to only present the code relevant to a given input condition
  • This is particularly useful for TPF as transactions are typically across a number of modules, so isolation of the code relevant to a particular transaction is a powerful analytical tool
  • Semantic Slicing isolates the code specific to a given transaction across these programs, then separates it from the rest of the code and represents the whole transaction process as pseudocode

A slice based on input message to retrieve a PNR

A slice based on input message to display a retrieved PNR

SML Dashboard

The Dashboard is a visualisation tool to provide insight into the processed code. It provides summary level information on; number of modules, lines of code and complexity. It also provides an overview of the relative size, complexity and distribution of the processed modules.

At a module level, it provides real insight into all of the detail of the module.

There are automatic links between the Flowcharts, WSL Pseudocode and Assembler to ease comprehension and to cross-check for a deeper insight

The Dashboard Summary Statistics for a sample project provide:

  • Total Modules – the total number of modules called in the processed code
  • Included – means the total number of called modules where we have processed the source code.
  • Source Lines – the number of source lines is the total number of lines in the modules we have
  • Executable lines – the number of lines actually executable – not including comments etc.
  • Dead Code – the number of lines not accessible by any route through the code
  • McCabe Complexity – Industry standard measure of code complexity, we provide a McCabe metric on the original Assembler, the restructured WSL Pseudocode and the improvement achieved in the restructure code.

At a module-level it provides real insight into the detail of the module including the following artefacts:

  • Statistics for the module – McCabe, Lines of Code( LOC)
  • WSL Pseudocode
  • Module Flowcharts with links to WSL Pseudocode
  • Assembler with links to WSL Pseudocode and Flowcharts
  • C or Java Pseudocode including Headers
  • Original ASM Source

WSL Pseudocode can use customer translations of technical terms/data names to create more business type names and labels

WSL Pseudocode text is coloured to aid understanding the colours mean:

  • Comments are grey
  • Collapsed comment header lines are yellow-green
  • TPF macro calls have a grey background
  • WSL Keywords are blue (IF, DO, EXIT etc)
  • Variables, fields, names are black
  • Operators are crimson
  • Strings are green
  • Text inside curly brackets are {business descriptions of the previous statement}

This is an example of a module flowchart, it fully navigable and where the text is brown there are customer translations to more accessible business style terminology. Just toggle on the Tech, Business buttons above or on the text itself

Code Process

Our goal is to accelerate getting the vast majority of code into the dashboard:

  • To unlock the speed of FermaT processing we separate the timeline for Exception handling from straight through (Fast Track) automatic module processing
  • SML has excellent analytics to keep track of progress and exceptions – Dashboard Integrity Tracker
  • Modules are re-included when exceptions are resolved
  • Typically 2-3 Million lines of code would take 3-5 weeks to Fast Track into the Dashboard

Fast Track Process:

  • Receive Customer Code – Check and store modules etc.
  • Set up customer specific environment for their Dashboard
  • Initial processing to identify Missing Modules, Logic Errors and Modules that don’t restructure
  • All modules with variances move to Exception Process
  • Everything else circa 98% of all modules proceed along the FastTrack – as fast possible to the Dash board
  • The Exceptions are picked up and dealt with individually in slow time – unconnected with the Fast Path but re-cycled to the Fast Path when resolved

Exceptions modules are triaged for any key issues and analysed in parallel with the FastTrack process then released to the  Dashboard

All artefacts are:

  • Statistics for the module – McCabe, Lines of Code etc.
  • WSL Pseudocode
  • Flowchart
  • Assembler
  • C Pseudocode including Headers
  • PDF’s

Next Steps – Add Modules to Exceptions Backlog:

  • Missing Modules send request to customer
  • Logic Errors inform customer of details
  • Restructuring problems – decide next steps