D*Code is built on a platform designed for flexibility and customization. While the tool does have a large set of built-in capabilities (e.g., size and quality metrics for COBOL programs), most customer engagements have needs beyond generic analysis. D*Code tool can be customized in terms of the input language, the output language, the legacy and target environments, the analysis performed, and the transformations applied. This allows D*Code to exactly match the needs of the project and enables analysis and transformation of systems for which no COTS tools exist.
Examples of customizations from UniqueSoft engagements include supporting custom extensions to COBOL and other mainframe languages, supporting proprietary legacy languages, supporting proprietary deployment environments (and creating transformations to remove the reliance on those environments), adding customer-requested analysis (e.g., Halstead Complexity) and displaying the results graphically, and creating project-specific transformations (e.g., fixing the "JOBOL" created by a third-party COBOL-to-Java tool and removing database access anti-patterns to reduce the time it takes to produce a report).
It is common on mainframes, especially in larger installations, for the languages and environments to have been customized by the vendor for the client's needs. For mainframe technologies not already supported by D*Code, and for client-specific customization to supported technologies, D*Code can be readily customized to support these legacy systems. For example, D*Code can be customized to check code against coding standards.
Domain-specific customizations have been done for insurance, telecommunications, ETL back-office support, database use, transportation control, finance, network control, data management, rule extraction for product support, inventory control, secure communications, authentication and authorization, and digital signal processing. The customizations have covered a wide range of application in D*Code. For example, support has been added for a proprietary legacy language so that applications across the entire company can be modernized, optimizations have been added for DSPs that can also be applied to new DSP families, identification and elimination of database read anti-patterns have been applied to multiple projects with heavy reliance on database access, and recognition of COBOL data layout idioms has been used to help transform COBOL to Java in multiple projects.
D*Code currently supports COBOL, Java and SQL as well as several deployment technologies, including CICS, DB2, UNIX/Linux, and various web and cloud frameworks. New input languages can be added by adapting the front-end parsers on the analysis tool.
The complex semantics of some languages are a challenge for tools that cannot perform deep analysis. For example, COBOL data layouts allow one to assign an alternate name to an existing field and to equate values and names. This is important both for analysis (for example, to determine which groups of identifiers are part of a feature) and for transformation to other languages (for example, understanding which 88 level declarations are the same concept as enumerations used in other languages). An 88 level can be assigned any value, so assignments in the code can provide values to the "variable" that was not in the initial declaration. D*Code can extract all values used in the program, including those given in assignments. If values come in from the environment, however, that information is not in the code itself. In this case, the tool allows the user to provide such informationso that the tool can optimize the transformation.
Translating between languages (for example, COBOL to Java) is a strength of D*Code. Other translations, such as from Java to PL/SQL can be added as customizations. Many of the issues of converting a flat-file database to a hierarchical or relation database stem from the primitive nature of the flat-file database. That is, the database is simply structured chunks of data accessed by their locations on the storage media. Database functionality that is common in modern databases (location independence, indexing, consistency checking, data schemas, data constraints, data normalization, asynchronous access, etc.) is part of the application itself in flat-file systems. D*Code helps uncover this functionality in the legacy code so that the database and the related code can be converted.
In order to understand the contents of the database, the related code must be examined. D*Code can analyze the legacy system, determine all code that reads from or writes to the database, extract the code related to the database, and present this information to the user. For example, denormalization is common in flat-file databases because of the difficulty in maintaining data relationships.D*Code can find all code that reads from or writes to the database, can find replicated code and data types which indicate denormalized data, and can detect specific types of uses of the data such as interpreting some data as an embedded pointer.
As part of the overall process, it is typically also necessary to migrate the related code that uses the databases. This migration covers how the database itself is accessed (e.g., the create and open methods), how the records within the database are accessed (e.g., the read and write methods), and how the data within the records is processed. As with conversion between languages, it is important to understand the database concepts as embodied in the code and to properly translate them, which is a strength of D*Code. For example, code related to hash-key management feature can be eliminated. In addition, code that depends on specific data types used in the database can be migrated to new structures as required. For example, types and code that rely on character values of T and F for Booleans can be translated to actual Booleans, making the resulting code much easier to maintain.
Since the UniqueSoft tool can be customized to check code against coding standards, these checks are also very useful in the transformation process, so that the resulting code after transformation adheres to the standards. This is not possible when using COTS translation tools, and it is a differentiator of D*Code.
D*Code is delivered as a self-contained virtual machine (VM) or as a docker container. This VM is installed only on the server, which can be any machine supporting standard virtual machines such as Oracle's VirtualBox or VMWare. This scheme enables rapid and centralized deployment of multiple customized versions of D*Code. The data is also stored on the server with the VM, allowing centralized access to project data.
Each individual user interacts with D*Code through a standard web browser such as Chrome. No special software is required on the user's machine. The tool license is independent of the number of users or the machines used to access the server.
There are several general differentiators for D*Code capabilities:
What it means to be a business rule can change in different domains and applications. In general, though, a business rule is composed of a set of conditions and an action; when some conditions become true, the associated action happens.
Business rules are extracted from the code using the following general process:
Other D*Code capabilities can be used in conjunction with rules extraction to provide more tailored rules. For example, rules can be extracted for a particular entry point to the code or for individual methods. The code itself can be preprocessed to focus on a particular product line (e.g., a type of insurance offering), to remove rainy-day scenarios, to eliminate dead code or refactor redundant code, etc.
The extracted business rules can be output in multiple formats (HTML, tables, etc.) or translate them to other languages (Java, SQL, FICO Blaze, etc.).
No. The generated source code and all required support code is provided.
Yes. Currently, D*Code currently supports COBOL, Java and SQL as well as several deployment technologies, including CICS, DB2, UNIX/Linux, and various web and cloud frameworks. New input languages can be added by adapting the front-end parsers on the analysis tool.
If the new language being requested is in common use and already on the D*Code roadmap, there is no charge for adding this new language. For unusual languages such as 4GL code generators we will quote a one-time charge to modify our front end to accommodate that input language.
D*Code can be customized to fully translate code to a new language and migrate it to the target environment.
UniqueSoft's standard business model is to license the D*Code tool to a systems integrator. UniqueSoft will support the project from behind the scenes with tool customization or consulting as required. In some cases, the systems integrator can also hire UniqueSoft to operated the tool on their behalf. There is an upcharge on top of the tools license to provide this service. However, this type of engagement will require that the work can be done at UniqueSoft's facilities.