Migrato uses IBM Bob to convert Java 8 installer to C++ in the Netherlands; three-day migration unlocks future Java upgrades
How Migrato used IBM Bob to turn a Java 8 roadblock into a three-day C++ migration
A legacy Java 8 installer was the biggest obstacle to Migrato’s modernization effort. Using IBM Bob™, the team rebuilt it as a native C++ application in just three days—unlocking future Java™ upgrades without disrupting customers. A software installer can become the hardest component to modernize when it depends on the runtime it needs to replace. Software firm Migrato faced that problem with a decade-old installer written in Java 8 that performed a narrow but critical job: it installed and updated applications in the company’s MICC (Migrato Intelligent Content Classifier) software suite. Because the installer itself depended on Java 8, Migrato was unable to use it as the mechanism for cleanly replacing the Java 8 runtime. This constraint meant that the modernization had to address both the application components and the installer path that bootstrapped them. As Migrato began a broader modernization program for its software suite, the team realized that the installer was their first blocker. Netherlands-based Migrato builds software that helps organizations analyze, inventory, cleanse and migrate unstructured content and has built its MICC platform with IBM technologies. Its six-person development team includes two senior developers and four junior developers, with most of its experience concentrated in Java and Python. Rebuilding the installer in C++ would remove the Java Runtime Environment (JRE), but the team estimated that learning current C++ practices, selecting replacement libraries and rewriting the application would take several weeks. IBM Bob helped the team dissect the legacy installer, plan the migration, generate the new implementation and validate the outcome. This optimization pared an effort expected to take several weeks to just three days. One developer used the AI development assistant to plan the conversion and generate the C++ code in less than a day. Manual code review, integration fixes and testing brought the total conversion effort to three days. The result was a functional installer designed to preserve the behavior of the Java application while running without a Java virtual machine (JVM). This post will walk through why Migrato isolated the installer first and how the Plan-to-Code workflow-translated Java packages and dependencies into a C++ project. It also shows how the team validated a cross-language rewrite without relying on a conventional code diff and how the new application creates a lower-risk entry point for the broader Java upgrade. Migrato’s MICC Manager controls licensing, server connections and access to applications across the MICC suite. It exchanges commands with the MICC installer, which installs, removes and updates components. The two applications also update one another. That arrangement works until the manager and installer both rely on the shared outdated Java environment. Updating every customer installation manually would add operational work and make upgrades harder to coordinate. Rather than attempting a full application rewrite, Migrato focused on removing its initial modernization blocker: replacing the installer’s underlying implementation while preserving its inputs, outputs and user-facing behavior. A C++ program runs as native machine code after it has been compiled for a target operating system, so the installer no longer needs the JVM to start. That separation allows the installer to update Java-based components and their packaged runtime without depending on the runtime it is replacing. It also keeps the rest of the MICC codebase in Java, where the team already has deep expertise. The team did not treat the installer as a reason to rewrite the entire suite or change its user-facing behavior. Customers can continue to initiate updates through the MICC Manager while the installer handles the lower-level deployment work. By automating that path, Migrato can reduce manual intervention across customer environments and make current software versions easier to deliver consistently. Migrato’s workflow follows a plan-implement-validate pattern: inspect the codebase, agree on an implementation plan, generate code and validate the result. Plan mode is read-only by design, which lets developers refine architecture and technical choices before code changes begin. The architecture diagram shows six stages, with human review spanning design, code, testing and security rather than appearing only at the end. The input was the existing Java 8 installer, its dependencies and roughly ten years of accumulated behavior. The Java implementation remained the reference for class names, methods, communication flows and tests. Keeping that baseline available was essential because a language conversion replaces entire files. It does not produce the line-by-line change set that developers normally inspect in version control. Bob analyzed the Java code and proposed a C++ project structure, conversion sequence and dependency map. Java typically groups classes into packages, while C++ commonly separates declarations into header files and executable logic into implementation files. Bob produced a tree view of the proposed structure and asked developers to choose among design options, including replacement libraries and whether to preserve Java-like organization or adopt a conventional C++ layout. The planning exchange also prevented unnecessary dependencies. When a Java class was replaceable either by a C++ library or a short custom method, Bob estimated the complexity at the developer’s request. For one case that required only about ten lines, the plan used generated code instead of adding another library. Such decisions reduce maintenance dependencies and can lower long-term total cost of ownership (TCO). After the developer approved the plan, Bob generated C++ source files, header files and the project structure. It mapped Java libraries to suitable C++ libraries and wrote replacement code when no direct equivalent would fit. The workflow added developer approval checkpoints before file operations were executed, so teams were able to review proposed file creations, edits, deletes and moves before the system applied them. That control was important because the conversion-removed Java files from the working copy and created a new implementation. The work ran against a separate backup, preserving a recoverable source baseline. The output is compiled into a native C++ installer for Windows, the environment used for initial validation. For Migrato customers with different operating systems, the installer can be compiled for the operating system and architecture without the JRE. This capability reduces the overall dependencies to run the installer on the target system and enables it to manage upgrades outside that runtime. Because the rewrite did not support a conventional before-and-after diff, the review compared two parallel codebases. Class and file names in Java were matched to C++ headers and implementation files. Reviewers then verified that required objects, methods and security-related behavior were present and understandable. Bob kept much of the generated structure close enough to the Java source to make this mapping practical, while deviations reflected language differences that reviewers were able to inspect directly. Testing used two complementary harnesses. Bob converted the existing Java unit tests, which check individual functions in isolation. Migrato also reused integration tests that drive the MICC Manager interface and observe its communication with the installer. Those tests checked the application boundary, making them more valuable than testing generated C++ functions alone: they verified that the new installer preserved its contract with the manager and functioned as expected. After review and testing, the C++ installer becomes the deployment entry point for future MICC upgrades. It can install current Java components and replace their packaged runtime without first requiring a separate manual runtime upgrade. Migrato can roll out the installer with the broader Java modernization rather than forcing customers through an isolated migration that delivers no immediate functional change. The conversion also surfaced the type of defect that generated code review alone won’t catch. The C++ installer started differently from the Java version, so it attempted to connect before the MICC Manager finished establishing their communication channel. The installer received an empty message, which later appeared as a decryption failure. That downstream error obscured the timing problem that caused it. With the help of Bob, the developer traced the failure through the communication path and recognized a similar timing issue from the Java implementation. The developer then adjusted the installer’s delays and connection handling. After that fix, the existing interface tests passed. The episode provides a useful deployment rule for cross-runtime rewrites: preserve observable behavior but retest timing, startup order, concurrency and failure handling. A faster or differently scheduled implementation can invalidate assumptions that were not stated in the source code. Human review remained the quality boundary throughout the project. Bob accelerated unfamiliar-language work and supplied current implementation options, but the developer chose the architecture, approved dependencies, checked security-sensitive code and validated integration behavior. That division of labor helped a Java-focused team complete a C++ migration without hiring for a one-off specialty while keeping engineering accountability with people who understood the production context. Migrato reduced an effort expected to take several weeks to three days: less than one day for planning and generation, followed by two days of review, testing and targeted fixes. The gain came from compressing research, project setup and mechanical translation—not from removing validation. Reusing the existing unit and interface tests kept the speedup tied to behavior that customers already depended on. The new installer also changes the end-user upgrade path. Customers can continue managing software through the MICC Manager while Migrato automates the runtime and application changes behind it. More consistent upgrades can reduce manual support work, shorten the time customers remain on older releases and give the development team a controlled way to introduce future improvements across deployed environments. By using IBM Bob to separate the installer from Java 8, Migrato turned a runtime dependency into a repeatable modernization pattern: choose a bounded application, create an explicit plan, generate against an approved structure and validate at both the code and integration boundaries. That pattern lowers the cost and risk of the next phase, where Bob can help upgrade the larger Java codebase and its application frameworks without forcing a wholesale move to C++. The result is a practical route to scale modernization while preserving the experience that MICC users already know.