Application Modernization and Rabbits

What can rabbits teach us about application modernization? Learn to incrementally refactor a decade-old monolith into resilient, event-driven microservices.

#1about 5 minutes

Using a rabbit analogy to explain application modernization

A simple analogy with rabbits illustrates the core benefits of modernizing monolithic applications, such as increased agility, better user experiences, and reduced costs.

#2about 3 minutes

Understanding the benefits and strategies for modernization

Microservices improve application resiliency, and key strategies for dealing with legacy code include retiring, rehosting (lift and shift), containerizing, or refactoring.

#3about 3 minutes

Comparing the legacy and modernized e-commerce applications

A demonstration shows the original 10-year-old Dojo-based e-commerce application and its modernized, container-based counterpart with a new UI.

#4about 3 minutes

Outlining the incremental eight-step modernization process

The modernization journey is broken down into eight incremental steps, starting from containerizing a Java EE monolith to implementing micro frontends.

#5about 5 minutes

Using tools to containerize a legacy Java application

The IBM Cloud Transformation Advisor and WebSphere Application Migration Toolkit are used to analyze legacy code and automate the process of moving it into a container.

#6about 5 minutes

Separating the frontend and migrating to open source

The application is refactored by separating the frontend and backend with REST APIs using a BFF pattern, then migrating the runtime from WebSphere to Open Liberty.

#7about 9 minutes

Using the strangler pattern to extract a microservice

The Strangler Fig pattern is applied to incrementally replace parts of the monolith, using the Mono2Micro tool to identify the catalog as the first microservice to extract.

#8about 6 minutes

Using event-driven architecture to decouple microservices

To avoid creating a distributed monolith with tight coupling, an event-driven approach with Apache Kafka is used for asynchronous communication between services.

#9about 5 minutes

Improving performance with modern runtimes and reactive code

Modern Java runtimes like Quarkus, combined with efficient JVMs like OpenJ9 and reactive programming patterns, can significantly improve application performance and efficiency.

#10about 7 minutes

Decomposing the UI monolith into micro frontends

The monolithic frontend is broken down into independent micro frontends using frameworks like Vue.js and single-spa, with RxJS for event-based communication.

#11about 15 minutes

Accessing the open source project and future plans

The complete sample application is available on GitHub with scripts for easy setup, and future work includes adding CI/CD pipelines for Kubernetes and OpenShift.