Video summary

Application Modernization made easy with OpenRewrite and AI | Emily Jiang

Main summary

Key takeaways

Technology

Summary (technological concepts, features, analysis)

The talk by Emily Jiang (IBM) explains why application modernization is increasingly urgent, what parts of an application to modernize (and in what order/effort level), and how OpenRewrite plus AI-assisted tooling can make modernization faster and less manual—often with no manual coding or minimal assisted fixes.

1) Why modernize (drivers)

  • Application boom + AI acceleration: By 2028, research predicts ~1 billion new applications driven by the AI wave, creating pressure on:

    • Infrastructure scalability (handle rapid growth and workload)
    • Security and compliance (more ways to attack; AI can also help attackers)

  • Technical debt blocks feature delivery:

    • Existing apps consume resources and expose CVEs
    • Research cited: roughly ¼ to ½ of development time can be wasted dealing with technical debt

  • Cost and business risk of outdated systems:

    • Mentioned ~$2.41T/year cost tied to cyber exposure, operational failures, failed projects, and maintenance of outdated systems
    • Examples:
      • Systems stuck with no source code, preventing upgrades
        • e.g., Java version upgrade is blocked
      • Older runtime/library end-of-support
    • Difficulty applying middleware/security patches and hosting workloads efficiently

  • Modernization isn’t overnight: waiting becomes “too late” when EOL deadlines approach.

2) What to modernize (strategy and categories)

Presented as a progression of modernization approaches, roughly by increasing effort:

  1. Maintain what still works
  2. Lift-and-shift (e.g., to containers) to reduce immediate cost/effort

  3. Re-platform (update runtime/platform for efficiency)

    • Example: migrate WebSphere Application Server → Liberty
    • Similar runtime moves:
      • Tomcat → Liberty
      • Tomcat → Quarkus
      • (and other comparable runtime/platform upgrades)
    • Possible Java upgrade: Java 8 → Java 21 (or newer)
    • Framework/version upgrades (e.g., Spring moves driven by related namespace/version changes)

  4. Refactor (more structural work; sometimes polyglot/serverless-style partitioning)

  5. Rewrite (e.g., monolith → microservices and API-first; requires heavier re-architecture)

Focus of the talk/demo: primarily re-platform for Java + runtime upgrades, with AI help for remaining gaps where no recipe exists.

3) OpenRewrite (automation engine for code transformations)

The talk describes OpenRewrite as:

  • Open-source tool for automated, large-scale code refactoring using recipes
  • Designed to avoid tedious file-by-file manual edits (“eyeballing it”)
  • Built around semantic AST-based transformation (“lossless semantic tree”), which can:
    • Preserve formatting and comments
    • Perform language-aware parsing
    • Apply upgrades across a whole codebase

It supports transformations such as:

  • Java version upgrades (e.g., Java 8 → Java 21)
  • Framework/namespace changes (e.g., Java EE → Jakarta EE; Spring namespace/version shifts implied as typical drivers)
  • Library upgrades, security patching, and other business-logic upgrades (via recipes)
  • Migration guides like WebSphere → Liberty

Deployment/usage mechanism mentioned:

  • Via the OpenRewrite Maven plugin and specifying active recipes
  • Best practice noted: run a dry run first to see which files will change

Governance/licensing note:

  • Recipe repository licensing changed previously from Apache—attendees should check licensing before using.

4) Where AI fits (to cover gaps beyond recipes)

OpenRewrite can automate many transformations, but:

  • It still needs known “before” and “after” states
  • It has limitations across conditional scenarios

AI-based code assistance is introduced as a complement:

  • IBM’s WatsonX code assistant capabilities described:
    • Add unit tests
    • Explain code
    • Most importantly for this workflow: provide modernization suggestions when no OpenRewrite recipe exists
  • AI can help verify correctness by creating tests and running them (conceptually described).

5) “Application Modernization Accelerator” (AMA tooling workflow)

A workflow/tooling approach described:

  • Input: an application (including cases where only binary exists) gets:

    1. Analyzed/discovered
    2. Visualized
    3. A migration plan/report is generated
    4. Then code changes can be produced:
      • Automatically via OpenRewrite recipes when possible
      • Assisted via AI suggestions for remaining issues

  • Output: the app can be modernized across targets (e.g., Java/runtime/container/cloud destinations).

6) Live demo highlights (VS Code + AI + OpenRewrite)

The demo illustrates a modernization journey:

  • Starting state:

    • Java 8 application
    • Java EE 7
    • Running on WebSphere Application Server

  • User actions (in VS Code):

    • Using an “X” code assistant
    • Select a modernization journey:
      • Source: WebSphere Application Server
      • Target: WebSphere Liberty
      • Java target: Java 21
    • Tool generates an analysis report and automated fixes

Example fix areas mentioned:

- **JNDI** adjustments
- Server name/API differences between WebSphere and Liberty
- Identifying WebSphere APIs used and mapping them to Liberty equivalents
- Java migration changes produced by OpenRewrite recipes

  • Automated fixes:

    • “Run automated fixes” triggers an OpenRewrite run and updates many files in the background

  • Assisted fixes (LLM/code assistant):

    • Two issues handled where recipes were not available:
      1. Superseded WebSphere API requiring a code change
        • AI suggests a replacement
        • Includes guidance about adding a missing dependency in pom.xml
      2. Java upgrade behavior change in an MBean constructor
        • AI provides instructions and helps verify field/value impact assumptions

  • Results:

    • Rebuild + refresh shows code updated and the application running on Liberty
    • Speaker claims modernization completed in ~10 minutes using tooling recipes + AI assistance

  • Additional demo detail:

    • OpenRewrite recipe list shown (e.g., Java 21 recipes, Spring Boot 3 modernization, namespace/package/type changes, security-related upgrades, library modernization, etc.).

Main speakers / sources

  • Speaker: Emily Jiang (IBM)
  • Primary tooling/source mentioned:
    • OpenRewrite (open-source; referenced as maintained by “Modern”/Modern vendor; creator mentioned as Felix)
    • WatsonX code assistant (IBM)
    • Application Modernization Accelerator (AMA tooling) (IBM)

Original video