Introduction
“Hi Bob, migrate the existing terminal Informix-4GL application to a Java web-based application.”
This straightforward request marked the beginning of my practical experience with IBM Bob, an AI-powered Integrated Development Environment (IDE) and modernization assistant. After learning about IBM Bob’s capabilities, particularly in legacy application transformation, I decided to evaluate its effectiveness using real Informix-4GL source code. This article summarizes my initial observations and results from that proof of concept.
Application Analysis
Working in planning mode, IBM Bob began by analyzing all .4gl modules to gain a comprehensive understanding of the application's structure. The system quickly identified that the legacy solution followed a modular, menu-driven architecture typical of terminal-based business applications. It produced a complete dependency tree of modules, clearly distinguishing between fully implemented functionality and incomplete components labeled as “Stub Only.” Report modules were also correctly identified and categorized.
Beyond structural analysis, IBM Bob extracted global variables and data structures and generated concise descriptions for each. The assessment then progressed into detailed module-by-module documentation. Each module was examined to identify menu options, associated business functionality, validation logic, and embedded business rules. For example, the system correctly recognized that the state value must be a valid two-character code, that customers with dependent orders cannot be deleted, and that phone numbers must adhere to a required format.
For transactional workflows such as order creation, IBM Bob documented the precise sequence in which data must be entered into forms. It identified real-time calculations embedded in the source code and confirmed that order submission logic was transactionally safe. The tool also analyzed .per form files to interpret user interface definitions, including formatting rules, color schemes, and layout patterns.
At the conclusion of the analysis phase, IBM Bob produced a high-level summary of the application’s core business logic. This included explanations of order processing workflows, data integrity mechanisms, and performance-related optimizations.
Migration and Code Transformation
The objective of this proof of concept was to migrate the existing Informix-4GL terminal application to a modern Java-based web application running in a containerized environment with Kubernetes deployment capability. Through a series of concise natural-language prompts, typically requiring only three to six conversational instructions, IBM Bob transformed the application into a structured three-tier architecture based on Spring Boot.
The resulting architecture introduced a clear separation of concerns. The presentation layer was isolated from the application logic, which itself was separated from the data access layer, while preserving the existing Informix database backend. This structured layering significantly improved maintainability, extensibility, and scalability compared to the original monolithic terminal design.
The modernized solution was built using Spring Boot 3.2.0 running on Java 17, with Maven 3.9 handling dependency management and builds. The persistence layer leveraged Spring Data JPA in combination with Hibernate 6.3.1 as the ORM framework, utilizing Hibernate Community Dialects to ensure Informix database compatibility. Connectivity was established through the Informix JDBC Driver version 4.50.7.
For the presentation layer, the application utilized Thymeleaf as the server-side templating engine, combined with HTML5 and CSS3 for structure and styling. JavaScript enabled client-side interactivity, while Chart.js provided support for analytics visualization where needed. Deployment was fully containerized using Docker, with Docker Compose orchestrating multi-container configurations. This foundation enables straightforward migration to Kubernetes environments for scalable production deployment.
User Interface Transformation
The initial migration preserved the familiar “green‑screen” aesthetic of the original terminal interface, allowing end users to keep their established workflow while gaining the advantages of a web‑based environment. The images below show examples of the resulting transformation.
While this approach successfully met the functional requirements, modern web standards typically demand a more contemporary and intuitive user experience. Continuing with the conversational development model, I issued a final instruction:
“Hi Bob, modernize the HTML UI ‘green screen’ to modern HTML pages.”
The resulting transformation significantly enhanced both the visual presentation and the usability of the application. The updated interface replaced the terminal-style layout with clean, modern web pages while preserving all underlying functionality and business logic. This outcome demonstrated that modernization can progress incrementally—from functional migration to full user experience enhancement—without disrupting core system behavior. The result is clearly very promising.
Additional Deliverables
An additional advantage of IBM Bob’s capabilities is the automated generation of presentation materials. The system can produce a structured PowerPoint presentation documenting the entire migration process, including architectural changes and analytical results presented in graphical and tabular formats. This feature accelerates stakeholder communication and supports both technical and executive reporting requirements.
Summary
This proof of concept demonstrates that a terminal‑based Informix‑4GL application can be systematically transformed into a modern web application while maintaining the integrity of its business logic and operational behavior. The migration preserved compatibility with the existing Informix database, introduced a well‑defined architectural layering model, and employed industry‑standard frameworks such as Spring Boot, JPA, and Thymeleaf. In addition, the solution supported containerized deployment and established a foundation suitable for scalability within Kubernetes environments.
Overall, the results indicate that AI‑assisted modernization can significantly reduce the required development effort while delivering robust, production‑ready outcomes that adhere to contemporary software architecture principles.
Jan Musil, IBM NCEE Technical Specialist