Wrangling the Cloud: Avoiding Missteps and Improving Application Environments
Accelerate Your Journey To Cloud-Native Architecture
Watch vFunction’s Samantha Cartwright, VP of Alliances, present how AI, data science, and automation can rapidly accelerate your modernization initiatives in ways never before possible. Originally presented at the 2022 Megacast, Wrangling the Cloud: Avoiding Missteps and Improving Application Environments.
Other Recommended Resources
The Best Java Monolith Migration Tools
As organizations scale to meet the growing tsunami of data and the sudden rise of unexpected business challenges, companies are struggling to manage and maintain the applications that run their business. When unprepared, exponential data growth can tax a company’s legacy monolith Java systems and their IT departments.
Intesa Sanpaolo Case Study (pdf)
In this case study we will describe the challenges, how Intesa Sanpaolo decided to convert one of its main business-critical applications from a monolithic application to microservices, and how a platform called vFunction helped to turn this challenge into a success.
0:00:08.6: And now it’s time for our next presentation in the application Environments MegaCast, our next session comes from vFunction, and presenting for vFunction is Samantha Cartwright, Vice President for Alliances. Samantha, welcome.
0:00:24.4 Samantha Cartwright: Hey, thanks for having me, guys. I’m really excited to present today and kick off, excited to tell you a little bit about vFunction, what we are, and even give you a brief demo of the product. So with that being said, let’s go ahead and kick off. So what is vFunction? We’re an AI app modernization platform. We take monolithic Java apps, we assess them, we analyze them, we design them and refactor them, all on a single platform. First thing I wanna mention is there are millions of Java apps out there. Traditionally modernizing these, especially the highly complex one that’s really been out of scope for a lot of enterprises, vFunction has really brought this legacy application back on to the forefront. You can actually start taking advantage of cloud native architectures a lot sooner. So let’s just jump in really quick and talk about just what is actually driving some of these modernization projects. A lot of you wanna modernize. You wanna take advantage of all the benefits of the cloud like scalability, elasticity, having shorter release cycles, meeting those security requirements, and really the last two, which I think are the biggest, is you wanna innovate faster and you really wanna tackle that technical debt.
0:01:35.9 SC: So the blockers below I think we’re all familiar with, but this is really what’s driving vFunction platform adoption, especially to help accelerate modernization projects at scale for both the enterprise and for partners. Legacy is hard to modernize, I think we can all agree on that. A lot of times, the projects, they either get started or they end up stalling out. A lot of this is because of complexity, so you have millions of lines of code to analyze, there’s dependencies, there’s history, and it’s really hard to get a confident graph on these applications, especially when some of them have five to 10 million lines of code and you’re not actually correlating the data at the right point, it’s near impossible to actually do this effectively without a lot of risk to yourself or your end customer if you’re a partner. Modernization is expensive, a lot of this is because of lack of automation. I’ll give you two scenarios that we often see. So, one for partners. If you’re a partner, oftentimes, the cost is astronomical if you’re going out to an enterprise and trying to win the business for a big modernization project. We’ve seen this happen a lot.
0:02:42.7 SC: If you’re the enterprise, oftentimes, you can’t even afford it because it’s so expensive or it’s this multi-year project, and again, it adds a lot of risk to the projects and it’s very, very costly for all people involved. After you’ve actually spent some money, you then realize this is such a time consuming process to actually try and refactor an app, especially because again, the skills gap are using tools that weren’t really fit for purpose. Oftentimes we see a lot of our end customers using tools like APM or basic static code analysis tools that really are only gonna give you half that picture and not even correlating data at the right point. And then the last one, which again, is probably the biggest that all lead up to this, is risk. Many of your enterprises have built businesses around this legacy application backlog, which is probably why at this point you haven’t moved a lot of it. It’s risky, it could hurt the economics of your business from bringing down critical systems to even losing productivity.
0:03:42.8 SC: Let’s move on and talk a little bit about how vFunction actually addresses these market problems. Again, we’ve developed this platform to really fill a major gap in the market. We’re a platform for developers and architects. We take monolithic Java apps, we assess them, analyze them, design them, and ultimately allow you to quickly extract them into microservices or mini services. This is completely done on the platform. Ultimately, this helps you build that repeatable factory model so you can actually deal with a broader set of applications. In some cases, we’ve seen our enterprises go from refactoring one over a few years to now doing it two to three applications a week, and again, this is really dependent on complexity. So again, you can onboard apps, analyze them, and continuously modernize. Now, just to summarize with the three numbers, so we speed up modernization efforts by 20X. Our customers often see 3X savings when they’re using our platform, and then ultimately we’re helping you derisk the whole project.
0:04:48.2 SC: Alright, now let’s talk a little bit about the prime use cases that we usually see. These are very broad, again, there’s probably smaller ones we could talk about, but let’s talk about the big three. Customers with a broad application estate, maybe you have a lot of applications, you don’t know where to begin your journey. This platform can actually help you make decisions on what applications to start with, really based on ease and impact for your business. The other one is customers with megalithic applications, so these are the really, really big apps. They begin their journey, it’s slow moving, there’s millions of lines of code, and maybe you don’t have the right skills or expertise or tools even to actually refactor that app. And then the last one, we see this quite often. People begin their cloud journey may be doing a lift and shift to start, and now you’re at the point where you wanna start your day two in the cloud modernization journey. So addressing your technical debt head on, modernizing architectures, and really starting to take advantage of the cloud native services.
0:05:49.5 SC: Alright, so now let’s talk a little bit about the platform. So I’ll give a quick overview and then again at the end, we’ll do some Q&A, but let’s just start diving into actually how the platform functions. So again, you’ve heard me talk about this journey, so we do take you on a complete journey from assessing your applications all the way the learning of the monolithic app, to actually fully functioning microservices. The first step in the platform is what we call the base modernization hub. I’ll talk about it in two parts, so if you’re a partner, this is a great pre-sales tool to actually help you in the business. If you’re an enterprise, this is a great way to start assessing multiple applications to see which ones to refactor first that would make the most impact for your business. This is lightweight deployment, you can get up and running in 10-20 minutes, it’s static code analysis only, so you can begin assessments on applications and get an automated report that gives you basically a technical debt breakdown, modernization recommendations based on what we call worst technical debt offenders, and again, this is really that starting point to start building that business case and figuring out what applications to refactor first.
0:07:02.4 SC: So the second stuff is the learn phase, so this is where you deploy the vFunction agent locally, wherever the applications are running on-prem or in the cloud, it doesn’t matter, it’s important to know so that the data actually never leaves your network and it always stays local, so we’re not a flawed platform, but you can deploy it in pre-production or production environments, but only in pre-production, you’ll need to actually run tests to expose the functionality of the app. So really the goal here during this learning and assessment phase is to identify flaws within the app that would actually correlate with specific domains. When we are thinking about decomposing an app, we’re looking to decompose it in such a way that makes sense, again, from that business value perspective, so it doesn’t make sense to maintain these as separate services. So what’s unique here is the ability to analyze the app from the UI, through the business logic to the database, and that’s really the main part of the dynamic analysis. So just to stress here, if you don’t understand the business logic, meaning the custom rules or algorithms that actually handle the exchange of information between the database and the user interface, it’s hard to effectively modernize.
0:08:10.1 SC: It’s literally the most important piece to understand the app and how it operates for the business. So, after this analysis piece is done, the static analysis of the BIC code, the dynamic analysis is then merged to really present this baseline microservices architecture. So the middle part, the analysis or automation phase, this is a place where you can really start assessing the complexity of your applications to determine readiness for modernization and maybe make changes to the application. This is what we call the V-factor hub. So, it’s an interactive microservices design studio where you can perform task on the UI, like merging services, splitting services, designing, blueprinting, calculating the ROI for refactoring, or rearchitecting or rewriting. Again, this is all done within the UI. So, once you’re actually comfortable with the design, this is when you would move into that service extraction phase. To me, this is really the easiest phase of it all, because you literally just click a button and it creates a service specification file for each of the microservices, and this then provides all the information needed for the vFunction platform to create service for you.
0:09:17.9 SC: So, by the end of all of these four phases, you have new projects, new microservices with APIs and you’re ready for deployment on any type of cloud environment or private cloud environment. So, let’s talk a little bit about how a typical project runs with vFunction, from assessment to POC, to first app actually being refactored. You can see here, it’s a pretty fast process and then really we get you to a point where you’re scaling and ready to build that repeatable factory model where you can start really refactoring at scale, and then ultimately the last phase, you’re already in the cloud, and now you’re just continuously modernizing the app to keep them in their most efficient state. So I’m gonna finish off on this and then we’ll jump into a quick demo, if that sounds good. So just to quickly go over our engagement model, so we work directly with the enterprise, but we also work with a lot of the hyperscalers, the GSIs and even smaller MSP partners. With that being said, let’s go ahead and dive in to get a quick view of the platform.
0:10:25.4 SC: In this demo, I’m gonna show you a quick overview of the vFunction platform. This is what we call the modernization dashboard, this is your single pane of glass or bird’s-eye view that allow you to manage your modernization projects. So how many applications have been created, how many are in the learning phase? This is where vFunction is actually collecting the data and assessing them, how many are in the analysis phase, this is where you’re working on the applications within the platform to actually design out those services, and then how many have actually been extracted and created, and then ultimately in the big green box, how many have actually completed the modernization journey? So below you’ll see these four boxes, this is really your summary statistic view, so giving you information on licensing, summary review of complexity breakdown of your apps, average time to modernization and platform usage. If we click the arrow below, we’re gonna get a detailed breakdown of all of the phases that we talked about earlier, and all of the application within those phases.
0:11:24.9 SC: So for the sake of the demo, I’m gonna go straight to the Analysis tab to see what applications we may consider for refactoring, these are applications that have already gone through part of the assessment phase, so vFunction really is two parts of an assessment depending on where you’re at in your journey, and I’ll show you both types for this specific demo. The first scenario I’m gonna show you is actually with the base modernization hub. So if you remember back to the PowerPoint, we talked about the different phases. This would be phase one of assessment. So let’s go ahead and click on an app. Alright, so the point of the Base Hub is really not to overly complicate things by showing you all the complexities within the app, it’s really to give you the simple view to allow you to build a business case and ultimately make an informed decision on what applications to prioritize for modernization. For this specific app, you can see that for every dollar I would spend, how much is gonna go to innovation, and then ultimately how much is gonna go to my technical debt. So for this specific app, you can see $0.36 will go to innovation, the other $0.64 is contributing to your technical debt, so really you have to spend 3X more to innovate in this specific application.
0:12:40.9 SC: So, let’s take a look at the worst offenders. So these are classes that are contributing most to your technical debt. If you were to fix them you could see how much your TCO would be affected. This is the beginning of your ROI story, but more so the beginning of the story of how to best approach modernizing this specific application. So, let’s click a little bit further and let’s see the debt breakdown, this is more on a technical level. So, let’s view things like complexity index, this gives you a gauge how complex your app is, factoring in things like dependencies, how things are intertwined, and for this specific app, you can also tell that the code is not very modular. If we look at risk, this is the length of the dependency strength, so if I were to start modernizing this app and look at one dependency, how much of the entire app would be effective? So to get to the debt index, we’re using a combination of risk and complexity to calculate this, and if you look at the middle lines, this is the average for your entire app portfolio, so if you had a client, with say 50 apps on the platform, it would calculate the average among all of them, this would give you the baseline on where the App stack reigns among the rest of them.
0:13:56.8 SC: So to summarize with Base Hub, this is best used when you have multiple applications to assess, this is gonna help you make the best decision on what applications to consider refactoring first that would make the most impact for your business. Keep in mind here, once the full platform is purchased, all of the data you collected stays on the platform and you can continue with the deeper analysis, so deeper like being the dynamic analysis and microservices design even after you’ve used Base Hub. So let’s go ahead and scroll down below, so this is now a view of the full analysis that vFunction offers, so this is both the static and dynamic analysis, you may have noticed a number on the right-hand corner of the applications on the home screen, that number represents complexity. So here, you can see this specific application is of medium complexity and these parameters are directly tied to the vFunction decomposition like class exclusivity, runtime service topology and more. This report will also show you the exact services that have been identified, this is the deeper and full ROI report that contains a dynamic analysis. So I’m gonna actually jump into another application to show you how we can use the V-Factor hub and the microservices design studio to start designing out a microservices architecture on a specific application.
0:15:23.6 SC: So what we’re seeing here is the ordering management system application, you can already visualize the potential domains that you can extract, each sphere represents a potential service that can be extracted, and when I hover over the service, you can see that it highlights it on the right, you can see things like this is the inventory service, shipping service, payment service, you can see that all of these are actual domains and the names are all done by the machine learning and analysis to actually name these services, the color of each sphere represents exclusivity. High exclusivity means it’s easier to extract the service, the greener are all the bubbles the easier it will be to decompose the application, but it doesn’t mean that you shouldn’t refactor the ones in blue as well, and this is where merging a service will make an impact on exclusivity, we’ll actually get to that in a bit. This is part of what goes into really the smarts and the cleverness in the platform, being able to identify those services regardless of existing endpoints in the system, this is why we need to see the actual flaws in the system, either in production or in pre-production environments where we run tests on the app in order to expose the different flaws within the application.
0:16:37.7 SC: So here you can see the dotted lines, these represent different calls between services, and what’s really powerful here is when you click on a specific service, you can actually see the different resources that vFunction analyzes, like bing, static variables, synchronization objects, database tables, transactions and so forth, and again, we’ve already clicked on a specific service, so you can see that the dotted lines have all turned solid now, this, you can see all of the shared resources among these services, so you’re seeing interdependencies between the services and you can start working on the platform to define entry points and refine the boundaries of those services. So I’m gonna show you one more thing. Let’s click on the biggest service, so the modify fulfillment controller. So let’s take a look at that. So here you can see things like entry point, dynamic classes, static classes, resources and dead code analysis, and for the sake of just to quickly show you other things you can view here for this specific service is if we click on exploratory, you can see all the functionality that goes into this specific service.
0:17:42.8 SC: On a deeper demo, we would actually show you how to work within this specific view, but I know we only have a short time, so I’m gonna go ahead and click back and show you some basic functionality that you can do directly on the UI, so I’ll show you a single action here, so let’s say you wanna merge two services, so let’s take the diners payment service and the payment service, and as an architect, I may decide, You know what? I wanna have a single service, not multiple payment services. So I can simply go to the diners payment service, drag it over the payment service, and the vFunction platform automatically ask me, “Would you like to merge these two services?” I’m gonna click confirm here and it starts re-calculating the entry points and re-calculates all of the functionality that goes into these services, all with their interdependencies. So by the time it finishes, you’re now gonna see that you have a green service, which means it has higher exclusivity and now it’s easier to move and extract. Again, this is one of the many examples that you can take directly on the V-Factor hub.
0:18:48.5 SC: But let’s say now I wanna extract the service and create a microservice from it, so let’s go ahead and save it. And now it prepares these two services for extraction, and you can see that the service creation tab is now available for me, so let’s go ahead and click that, this is where you could start configuring the service, like what is the target platform, the dependency repository, and from there, it’s just a matter of configuration and clicking on the extraction files to get the files needed to actually extract the service. For the sake of this demo, we’re gonna stop here but we’ll allow for some questions at the end. Again, if you want a deeper demo, we’re happy to do so, we have some links at the end that you can fill out and propose from there. We’ll go for Q&A session next. Thanks guys.
0:19:49.7: Alright. Well, Samantha, great presentation, cool demo. I love the way you turn technical debt into a percentage metric, and the tools from there look really powerful. And before we get started with the questions, do you wanna just talk a little bit about the learn more links here? Just because we will go to a poll question, so I wanna make sure that you get a chance to look at what’s up here.
0:20:14.4 SC: Yeah, no problem at all. Yeah. Look, we would love to teach you more about the product, give you an in-depth demo if this makes sense for you. Also, feel free to request an assessment of your Java app. And then the last one which I’ll mention is, we would love for you to join our beta program for our newly released Base Hub assessment, which I showed you in the demo. So click any of these links, we’d be happy to engage, and look forward to speaking with a lot of you. And then, yeah, let’s go into Q&A.
0:20:44.3: Alright, super. Well, let me go ahead and put the poll question up here. So we appreciate everybody’s answers on what additional information you’d like from vFunction. And this is also a quick reminder that we, in addition to the other prizes, we have the $50 prize for the best question, so be sure to get your questions in there. So the first one we have here, Does vFunction decompose the database or just the business logic layer?
0:21:17.0 SC: Yeah, no, that’s a [0:21:19.3] ____ some of it in the slides but happy to kind of dive a bit deeper here. So that’s another key area in the modernization process, so our dependency analysis in our analytics, actually look at all of the database calls. So for part of the microservices recommendation, taking into account trying to decompose where the database calls are, so we don’t decompose the database, but we provide all the mapping in terms of what services are calling what database tables, and typically then afterwards, you have microservices that are actually calling portions of the database, and those were distinct isolated calls. So it’s actually much easier to decompose once you have the rearchitecture process concluded with vFunction. So typically, people do the microservice decomposition, which takes into account all of the database tables called, but then move into a cloud native database or sometimes they just leave the database as is, because the data is something very sacred to many people and they don’t wanna touch it. It’s all part of how you’re planning to really engage that modernization rollout.
0:22:24.5: Okay. This next one, they’re asking, “How does vFunction identify and remove tech debt?
0:22:33.4 SC: Yeah, another great question. Well, tech debt is really at the core of modernizing, so tech debt is what makes it very hard to innovate an organization. These lean organizations, for every dollar they use on innovation is about $0.25, when $0.75 go into feeding your technical debt, that’s the real problem that you’re trying to solve with modernization, and it’s really important you assess these and measure the amount of technical debt as you engage in these modernization projects.
0:23:03.8: Okay. Probably got time for one more. Here’s one. How much is the Base Hub assessment tool? And where can I get it?
0:23:11.4 SC: Yeah, it’s in beta right now, and we’d love for you to be part of it, and the link, I think is on that last slide, so if you fill that out, I’d be happy to engage with you further about pricing.
0:23:23.5: Okay, great. Well, I’ll pop that slide back up, but it’s all the questions we have time for. Samantha, thanks so much for coming on and bringing us up to speed on vFunction and participating in this MegaCast. 0:23:39.3 SC: Yeah, thank you for having us. We really appreciate it.