According to the Enterprise Strategy Group, 94% of IT professionals surveyed believe their organization will increase cloud-native spend over the next year to year and a half. The cornerstone architecture for a “cloud-native” application is one that runs off of microservices, where each service or component is built around a specific task and interacts with the other services through APIs. The advantages of using microservices include a reduction in time to scale through faster development and deployment as well as the ability to leverage containers which are another component of a “cloud-native” application.
Legacy monoliths vs modern microservices
For those who have systems built in legacy languages and technologies and are considering their modernization options, it’s important to understand the tradeoffs of moving to “cloud-native” development. Legacy applications were typically constructed in what’s called a monolithic architecture or as a single unit. When applications are small, this kind of architecture can work well for speed of development, testing, and deployment. However, as an organization needs to update and scale their applications, it can lead to major challenges as each application needs to be thoroughly reviewed and tested when changes need to be made. While microservices architectures do require some extra effort when designing and testing communication between services, they provide the flexibility needed for organizations looking for greater business agility.
Legacy application modernization and where microservices fit in
As organizations face increasing pressure to increase efficiency and innovate, they are starting to realize that maintaining a status quo with their legacy applications simply won’t cut it. While these applications are written in a suite of various programming languages, the most prevalent is COBOL. In fact, 70% of large corporations still run many critical applications written in this language. However, the talent pool available to support these applications and those written in other legacy languages is quickly shrinking. Modern technologies that allow for more innovation options and more efficient maintenance provide a strong incentive to move forward with a plan to update these applications. Moreover, failing to modernize may leave an organization vulnerable to security, reputation, and revenue threats if there are weak links in these systems.
As organizations move forward and start to determine their modernization options, there are really two paths forward after assessing the current state of their applications. The two paths are:
- Business Rules Extraction: Extract and export business rules to a modern off-the-shelf platform (Replace) or use those rules as target specifications for a rewrite of the application (Rebuild). Currently, those who choose the “Rebuild” path would likely choose to create the new application using microservices given current trends.
- Code Optimization & Migration: Clean up the code and migrate it to a modern language/architecture (Refactor). This path should be used if the organization is not looking to make too many enhancements. Traditionally, this type of code conversion has left out both the “optimization” and “modern architecture” parts and simply used a line by line translation to take code written in an older language like COBOL and translate it into a more modern language such as Java. However, this approach meant that the code optimization process as well as the architecture change was left to IT teams to address after the modernization project. Teams were therefore running highly inefficient code, until they could find the time and resources to make the changes. Inefficient code means higher times and costs of running and maintaining applications as well as continued blind spots into the overall health of these applications.
At EvolveWare, we believe in a different approach to the code optimization & migration path. Consequently, with some of our recent product releases, we’ve created a solution that addresses the most pressing challenges mentioned above.
COBOL optimization and migration in the Intellisys platform
The Intellisys platform is the only end-to-end platform that automates the processes involved in application modernization including documentation, analysis, optimization, rules extraction, and code conversion. Its “Code Optimization & Migration” solution allows organizations to modernize their code and architecture using defined processes and automation to speed up the process and mitigate risk.
In the latest release, we decided to focus on the migration workflows for COBOL to Java and COBOL to C# by adding capabilities to generate microservices for the transformed code. Transformations for these languages, such as a project we worked on with Arlington County, tend to be the most common requests from our customers.
The new and improved workflow for this type of COBOL modernization is as follows:
- Assess the source system: Source code is processed through Intellisys to extract its meta-data and storing that meta-data in a repository. Users can then generate documentation artifacts from that meta-data including diagrams, reports and logic representation in multiple formats. These artifacts can be reviewed and analyzed using the analysis features of Intellisys.
- Optimize the code for its future state: Based on the analysis, users can then use the optimization features of Intellisys to update the extracted meta-data. Optimization features include deactivating dead code, renaming cryptic variables, merging or splitting logic, removing redundancies, and normalizing the data model etc.
- Define microservices and generate target code: Once the meta-data has been optimized, Intellisys can generate target code that has no proprietary dependencies, has modern architecture frameworks like Spring, and is maintainable and scalable. This automatically generated code is approximately 80% complete. The remaining 20% of the code does require manual service.
Intellisys supports the generation of microservices from COBOL, C# and Java application code. To create these microservices, a user can select a method of a class as the endpoint and Intellisys will identify all the dependencies for the selected method, which the user then reviews. The user is also presented with options for generating the microservice including the ability to modify dependencies. If the list of dependencies is not modified, Intellisys will generate microservices that both compile and execute. It will also generate code to test the invocation of the microservice. If the dependency list is modified, the user will be responsible for resolving any conflicts or missing functionality after the microservice is generated
The future of code optimization & migration
These enhancements are just another step in our journey to provide our customers with the ability to transform and create modern applications and workflows. Our goal is to continue to make this process more automated and streamlined while keeping the user in the driver’s seat. Future enhancements to microservice generation will rely less and less on the existing code structure and provide additional flexibility. As modern technology continues to change, we must also continue to evolve alongside it.