WebSphere Application Server & Liberty

What's New in IBM Mono2Micro 21.0.06

By Len Theivendra posted Fri June 18, 2021 04:13 PM

  
The June release of IBM® Mono2Micro introduces a host of new features to help you view and interact with application and analysis data in more intuitive ways, efficiently handle large amounts of data for huge applications, and provide new ways to filter and analyze the refactoring recommendations, all in order to make your refactoring journey to microservices on WebSphere Liberty even easier.

Let's start with the new look and layout of Mono2Micro's UI where you can view the AI's analysis and recommended partitions, customize them, and gain various insights into your monolith Java application.




There is now a dedicated graph controls panel on the left side that can be collapsed/expanded, to provide all of the view controls, actions, and filtering options in one place. On the right side, the information panel still exists and is now dedicated to displaying information and properties based on context and what you've clicked on the graph itself (i.e. partition info, class info, etc). This panel can also be closed to provide more working space for the overall graph. On the top section of the UI, a global search bar is there for you to search for classes in whatever view you happen to be in, and to the right of that are buttons to load and save graph files, launch a tour of the product, etc.

When dealing with the analysis of a large application and collected data, you might be dealing with a fair amount of partitions and hundreds, if not thousands, of classes in each, and this is where our other new feature comes in handy, a mini-map!




With the mini-map you can zoom in on any specific area of the entire graph to view partitions, classes and observed runtime calls more clearly, and use the highlighted moveable rectangle to orient yourself within the graph.

Next, let's explore the new filtering options available in Mono2Micro's UI. First up is the ability to filter out partitions, classes, and runtime calls associated with a chosen set of use cases. This is a great way to isolate the section of the monolith codebase that is involved in a single (or more) use case that you're interested in, and see how the code involved has been distributed in a partitioning recommendation. In addition, it gives you more insight into the functioning of the monolith and all the code that was executed in a select use case or set of use cases. Using the DayTrader application as an example, when filtering just for the two use cases representing the buying and selling of stocks in the business logic partitioning view the following is shown, indicating that partition1, partition2 and partition3 are involved, with just one class in partition3. This can then be of help for you in further customizing these partitions, such as moving that one class HoldingDataBean to partition1 as an example.




The other new filtering capability in this release of Mono2Micro allows you to filter by runtime call volume. When you hover over any edge between classes in the graph, Mono2Micro will show you the amount of times that runtime call (or flow of execution) from one class to another was observed. And noting the volume of these calls, especially if those calls span across partitions is important since that speaks to the level of coupling between partitions that will have to be noted and handled as the partitions are eventually implemented as microservices.  In particular, runtime calls with a high volume of calls might be of particular interest, pointing to perhaps the partitioning needing more customizing in order to move those classes into the same partition, or re-writing of code to remove this inter-partition communication altogether, or maybe even copying one or more classes to multiple partitions to avoid inter-partition calls, especially if the class(es) involved don't necessarily have to be part of a future service. Using the DayTrader application again as an example, the following shows how to use this filtering.  In this case, we set the filter to show runtime calls whose volume is greater than or equal to 1000.




Additionally, this is a great way to simplify the graph view and only show edges (i.e. runtime calls) of your choosing.

One other improvement and capability we added to this release of Mono2Micro was the ability to see existing class dependencies that Mono2Micro observes in the monolith Java application, right within the partitioning recommendation views. When in the Business logic or Natural seams views, you can now click on a class and Mono2Micro will show any class containment dependencies that class might be involved in. As a reference, class containment dependencies refer to cases when one class uses another class as a state variable or as a method argument/return type. The following example shows all the class containment dependencies the HoldingDataBean class is involved with via the dotted lines. In this case, classes AccountDataBean, OrderDataBean have a class containment dependency on HoldingDataBean, and HoldingDataBean has a similar dependency on QuoteDataBean.




Finally, let's check out Mono2Micro's new capabilities for handling unobserved classes inferred from the use case data that it analyzes. As a reference, unobserved classes are those which Mono2Micro observed in the input monolith source codebase, but did not see in any of the use case trace logs that was provided to it. This usually either means that use case coverage was insufficient, or these classes could potentially be dead code. Beforehand in Mono2Micro, the unobserved classes were shown in a special 'Unobserved' partition in all the partitioning views and you could view and customize them as you would for any other partition's classes. But it wasn't a true partition in the sense that it formed the base of a potential microservices, but more so to collect all the unobserved classes together so that you can take actions such as moving them to partitions, ignoring them as dead code, or running more use cases to cover their usage, etc. This can get unwieldy especially for applications where there are a lot of unobserved classes.  To help with all this, this release of Mono2Micro introduces the ability to work with unobserved classes in a separate view as a table, launched by clicking on the 'Unobserved classes' button in the top right section of the UI. Once launched, you can view them in a configurable paginated manner, select multiple classes and perform actions on them such as moving them to a particular partition when in edit mode, or assign tags to them to indicate actions you want to take or whatever other information/action you want to associate with the classes by creating your own tags. You can also search for classes or class name patterns right within the table, and choose to also show them in the graph in the empty space between partitions, which you can later move to partitions when in the custom view, etc.




That covers the bulk of the new capabilities and improvements in Mono2Micro 21.0.06, be sure to visit https://ibm.biz/Mono2Micro and check out all these new features by trying the interactive demo and updating your existing Mono2Micro images.



#ApplicationModernization
#mono2micro
#microservices
#JavaEE
#WebSphereLiberty
#AI
#ML
#Java #migration#bestpractice
#monolith
#OpenLiberty
#Liberty
#WebSphere#WebSphereHybridEdition

​​​​​​​​​​​​​​​​​​#whatsnew​​
0 comments
55 views

Permalink