Landing Page Clusters Graphic

AI for Application Modernization:

Accelerate Your Journey To Cloud-Native Architecture

Watch vFunction’s Amir Rapson, CTO and co-founder, and Bob Quillin, Chief Ecosystems Officer, present how AI, data science, and automation can rapidly accelerate your modernization initiatives in ways never before possible. Originally presented at the 2022 Application Architecture Summit by Integration Developer News.


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.

ROI Calculator

The vFunction Return on Investment (ROI) calculator determines the key benefits – based on actual customer metrics – achieved by using the vFunction cloud native modernization platform including:

  • Time to Market Acceleration
  • Total Cost Saving
  • Total Time Savings

Video Transcript

0:00:00.1 Vance: And welcome to the vFunction session here at the Application Architecture Summit where we’ll learn about how AI is helping enterprise companies modernize and migrate their legacy apps for the cloud. And with us this morning we have two terrific speakers, Amir Rapson, founder and CTO of vFunction and Bob Quillin, Chief Ecosystems Officer. Gentlemen, welcome.

0:00:21.5 Amir Rapson: Happy to be here, Vance.

0:00:23.8 Bob Quillin: Thanks Vance, it’s great to be here.

0:00:26.0 Vance: Yeah, and we’re really glad to have both Amir and Bob with us. Amir Rapson, the founder and CTO as I mentioned, his expertise is to combine Java with modern techniques to embrace microservices, Kubernetes and containers for migration and modernization without any errors or hiccups in your progress. And Bob Quillin for his part focuses on developer advocacy, marketing and cloud ecosystem engagement to help enterprises accelerate their journey to the cloud. And notably, he was a former Vice President of Oracle Cloud Developer Relations, so he knows a lot about Java and the cloud. And the expertise comes together in their session this morning, “AI For Application Modernization.”

0:01:06.6 Vance: If you’re among the growing number of today’s largest enterprises looking to make their legacy on-prem apps ready for the Cloud, either through hybrid architecture or native cloud migration, you’re in the right place, vFunction leverages AI and proven methodologies to modernize Java applications and helps you accelerate migration to the cloud. This includes the ability to automatically and quickly extract efficient microservices right from your complex monolithic apps. And what’s so cool today is that not only do we have a great slide session, but we also got a great demo that shows you exactly how that’s all gonna work.

0:01:41.6 Vance: Just a quick note before I hand it to our speakers this morning, you can get today’s slides just by hitting that big red button on the view screen, you’ll be able to download the slides. Speaking of downloads, we’ve got some other great resources all available for you with just one click right under the view screen. See those blue links, they’re for you, and we love your questions. So to connect with our speakers just type in the ‘Submit a question’ box. So gentleman, AI for application monetization. Great topic. Bob, I’ll hand it to you.

0:02:11.6 BQ: Thanks, Vance. It’s great to be here. Once again, I’m Bob Quillin and I lead the developer ecosystem here at vFunction. I’ll be joined by Amir Rapson, our CTO co-founder who’ll do a great demo, and let’s jump on into it. Today we’ll be talking about application modernization, and vFunction brings a very unique and innovative approach. We’re applying AI and machine learning to a very difficult problem about moving monoliths into microservices and helping you to accelerate your journey to cloud native. So as we talk about application modernization and the drivers and blockers behind that, application modernization is being pushed in the enterprise by a range of issues. Part of it is moving to the cloud and the scalability and elasticity that comes from that.

0:03:00.3 BQ: From there, you get a lot of agility and benefits from both an engineering and a business perspective. The security holes that are emerging every day around your legacy code, and also almost more importantly, the technical debt that’s developing is inhibiting innovation. Almost 75% of IT budgets are going to legacy systems and that is dramatically affecting the ability to innovate and drive new technology and new business services into enterprises today.

0:03:30.1 BQ: So why is this a problem? Why is this hard to do? Well, application modernization is complex. These are complex monoliths, millions of lines of code, lots of deep dependencies. People think of them as balls of mud, very tangled messes. It’s very costly in terms of people, in terms of the tools that people use, the licensing you’re supporting and how people do it today in a very manual approach. It takes a lot of time because there’s a lack of automation. The skillsets are difficult to attain and there’s no tooling associated with that, there’s no tools that actually automate this process and make it easier. And the risk to actually changing a monolith that’s an enterprise application is business-critical is very high, so therefore a lot of people avoid the change ’cause they can’t afford the downtime associated with that.

0:04:21.4 BQ: Well, part of modernization is really looking across a variety of approaches that people are using, from re-hosting, re-platforming, to re-architecting. The more you modernize, of course, the more value you get from the cloud, and the value from the cloud you’re getting are things that really drive value from a business perspective and engineering perspective. Elasticity, increase innovation, faster release cycles, etcetera. And as we look at how people modernize today, a lot of them start with a very tactical approach where they lift and shift, where they’re re-hosting or re-platforming their applications.

0:04:54.9 BQ: Now, re-hosting is something that helps you move the applications off-premise, maybe close down some data center facilities, but it doesn’t really tap into the full value of the cloud. Other people try to take their monolith and move it into a container and re-platform that. And you get some DevOps benefits there, you get some [0:05:12.9] ____, but you’re still at the end of the day dealing with a monolith. So in order to get the full value of the cloud, you have to look at re-architecting your monolith in terms of refactoring and restructuring, rebuilding or rewriting the whole thing, and this is really where vFunction comes in.

0:05:27.0 BQ: We’re looking to take that monolith, move it into microservices so you can take advantage of all the stuff the cloud native has to bring. With accelerated change, people are also now looking at continuously modernizing as the strategy going forward. Today’s applications soon will become tomorrow’s monoliths, so continuous modernization is the latest strategic approach that extends modernization to something you do every single day; vFunction itself is a platform for application modernization, where it applies artificial intelligence to intelligently and automatically assess, analyze, decompose, rearchitect and extract microservices out of the monolith itself, it’s designed for developers and architects specifically and is focused on the architecture itself.

0:06:17.8 BQ: It allows you to transform and modernize those monoliths into either mini services or microservices and provide a structure to continuously modernize those applications as you go forward, that includes removing dead code and also taking those monoliths, taking microservices and extracting them into a Cloud Native Architecture. It’s repeatable, it’s scalable, it’s automated and it’s something that allows you to build a factory model. Most people have not just one monolith but tens, hundreds, sometimes thousands of monoliths of trying to build a factory model around. So continuous modernization is a simple extension of a CI/CD strategy where you’re continuously applying these modernization approaches to all your applications going forward, vFunction then allows you to accelerate the delivery of those microservices at a much lower cost in a much better risk management position.

0:07:15.1 BQ: The vFunction platform consist of three different phases, the first phase is a learning and assessment phase where you apply both dynamic and static analysis. We think of dynamic analysis as something that’s similar to what an APM or Application Performance Management system does, the static analysis, looking at the static by code. We’re not looking at the actual source code at this point, we’re looking at the behavior of the code, we’re looking for interdependencies in real time as it operates either at a staging environment or in production.

0:07:45.1 BQ: As we build this model, we’re able to build a set of reference services and a reference architecture that we then in the second phase illustrate through a studio to the architect itself and the architect will then apply their rules, and you’ll see there are various aspects of control that the architect has in the demo that’s coming up that Amir will provide. This is where we use the AI and data science, sort of low code approach, put together a microservice design where you could then combine services, split services and actually elevate and extract the services you’re looking to move to a microservice architecture into third phase.

0:08:19.7 BQ: This is the first step we actually look at and where we actually use the source code to create a new project that you can then containerize and move to a Cloud Native environment. Be it up in the cloud, AWS, [0:08:31.4] ____ Cloud, Azure, etcetera or a Cloud Native Architecture, HPE, OpenShift, OCI, etcetera. So what do enterprises do today? They’re using a variety of different tools that are static code analyzers, that are basically in the tool box as a software engineer. You’re using APM tools, Java profilers, things like AppDynamics or DynaTrace, New Relic, Datadog, they actually look at the performance of an application and give you some sense of behavior, or they sit around in a room and actually look at all the services, to get all the architects together and spend weeks, if not months, trying to do this in a very manual approach in a conference room locked-up, in a very painstaking process around domain-driven design and event storming.

0:09:16.9 BQ: VFunction automates that process, it automates the domain-driven design and event storming by looking at the stuff operating in production or in staging by running test against it. It’s a single holistic platform that can then be used for a single application or for multiple applications in your environment at a factory level, on a continuous level, specifically designed for architects and developers, give you the visibility in-depth and analysis to actually then extract the services you want, be that one service or multiple services. Uses data science, machine learning to identify those services that gives you the control to define which ones you wanna extract and how you wanna model that in your environment.

0:09:57.7 BQ: The three primary use cases that we see in our customer base go along the continuum of the Cloud Native journey. Early on in the environment, we see people using vFunction to assess their application state. We’re trying to decide whether we host, we platform, we write, we architect, etcetera. Or they’ve actually have several very megalithic applications, there are 10 millions of lines of code, maybe they’ve been working on these applications years and years, but they’re stuck and they can’t move on. This gives them a catalyst to actually dive in and actually analyze the application to pull out maybe a single service or maybe a set of services. Sometimes they’re doing this very selectively in terms of refactoring and just pulling out one or two key services at a time. This is something that we’ve seen very often that we help with using our dynamic analysis, but it actually scales very nicely to these large monolithic applications.

0:10:49.6 BQ: There’s also customers who have lifted and shifted to the cloud already, they’re running up in a cloud environment, but they actually just re-hosted that application, or re-platformed it, and just running up in a container in the cloud. And now they’re looking to take advantage of all the cloud benefits. So vFunction can help you through its modernization hub, it’s assessment ROI reports in its earlier phases of the application Cloud Native journey and the modernization journey. And then as you move forward in terms of actually doing the modernization, our AI-based analysis of decomposition and extraction can help you there too. So at this point, I’ll hand it over to Amir who will walk you through a demo.

0:11:28.2 AR: Thank you, Bob. So what are we looking at now is the analysis screen of the vFunction platform, and what we’re about to do is analyze a small application, which is a demo application that we wrote, it’s called an OMS or an Order Management System, and it mimics the behavior of a retail application that deals with order, shipping, pricing, etcetera. So this would be a simple application, but follow the process and follow the methodology and imagine that you’re looking at a much more elaborate application.

0:12:01.2 AR: So what we see in front of us is the initial view of the platform, where the algorithms and the data science of the vFunction platform present to us the services that are offered by the system to extract. Now at this point, the architect will interact with the system and decide on their own architecture and their own services, so let’s focus on what we’re seeing now. What we see in here are these circles, so each circle or each sphere represents a service. The size indicates the size of the service in terms of number of classes, the color indicates exclusivity of the service, which is a very important term in the vFunction methodology.

0:12:43.9 AR: Exclusivity is the percentage of classes that are exclusive to a service, so if you want to extract a certain service where you want a higher degree of exclusivity, ’cause you want these classes or that domain to exist solely within this specific service. So green would be a high exclusivity service, blue is a medium exclusivity service and pinkish red would be a lower exclusivity service. We also see these dotted lines, these dotted lines are calls between the services. And this is really the architecture view, this is the remainder of the monolith, these are calls to the services, and we have a few service to service communication as part of this simple application.

0:13:24.7 AR: So let’s start to focus on one of the services and see what information we can get from the system. So this large one that we press on, this is the Modified Fulfillment Controller. These services get their names based on the algorithms of the vFunction platform, they get their names from the classes of the methods that invoke these services or from text terms that repeat themselves within the classes and methods of the service. And based on that, it gives you an idea of what you’re looking at. So this is the Modified Fulfillment Controller, it immediately gives us an idea of what we’re looking at.

0:14:00.9 AR: So it has two entry points, we see that here, entry points are the methods that invoke the service. Let’s click on exploratory and view that. So here, we’re seeing the call stack, so this is a view that you may be familiar with through profilers and such, so you see here the calls between the classes and methods and what really happens in the service. It’s important to start with the dynamic analysis, so what we see here, the call stacks themselves, ’cause they’re the runtime dependencies, they’re what’s actually running in the service and that helps us kind of gain the understanding but also set the right boundaries of the service.

0:14:37.0 AR: So we see here that the boundaries of this service are from this marker here, from this Modified Fulfillment Controller method up until these markers here all the way here with these parts of the service. Going back, we can also look at this from a class perspective, so let’s look at the classes that we found in the dynamic analysis. So we see only five classes that are first party classes with an 80% exclusivity, which means that four of these classes would be exclusive and one won’t be. Let’s view those. So we do see four exclusive classes, we see the Modified Fulfillment Service, the controller, sales order, line charges, they’re all exclusive.

0:15:20.3 AR: We have an infra class, which is a logger, it’s a class that’s used widely in the system and vFunction offers to put this in a common library, and we also have a non-exclusive class, which is the shipping service. For me it doesn’t make sense that the shipping service is part of the Modified Fulfillment Service, but let’s see where it’s used. So we click on the details, see that it’s used in two different services, the Modified Fulfillment Controller and the Shipping Price Controller.

0:15:48.4 AR: Let’s say that I want to move the shipping service to the Shipping Price Controller, I don’t want that class at all in the Modified Fulfillment Controller, so I can click through here and the system immediately takes me to the right place where I can change the boundary of the services and add a call, instead of a class to class call or a method to method call, to a service to service call to the shipping price controller. Clicking on “make,” the system will automatically calculate all the metrics and show me all the architecture. So you see here, there was a little progress bar. Going back to services, I can now see this little dotted line between these two services and effectively I have changed the architecture. I can look at the Modified Fulfillment Controller and see that now I have four dynamic classes with 100% exclusivity, meaning that the shipping service is now exclusive to the Shipping Price Controller service right here.

0:16:42.6 AR: So really looking at the boundary and changing the boundaries of the services to increase exclusivity is the first step when looking at a monolith with the vFunction platform. I can also look at the resources. So vFunction tracks objects or resources that may either hint to a certain domain or pose a certain constraint you’re extracting a service. For instance, we see here, when we look at all the types, we see beans, like Spring Beans or EJBs and JE applications, files, database transactions, database tables, etcetera.

0:17:16.9 AR: So here too, we can focus on the non-exclusive resources. For instance, on this order line table, which is a read/write table and it’s written to from this service, from this Modified Fulfillment Service, but just by the name, the order line, I can make a decision that I want this order line table to be called only from the order service. So I click on the details again, I click on the modified fulfillment here again, I get to the right place in the call tree, where I want to add a boundary, when I want to add a service to service call, and again, this is only for the sake of the exercise, of the demo, I’m not entirely sure that this would be the right architectural choice, but let’s add a call to the order controller right here.

0:18:06.4 AR: Going back to services, let’s wait for the analysis to run. Okay, we look around at the progress bar, it’s done. Now we see that there is not only a call to the shipping service but also a call to the order controller. And now looking at the order controller and looking at its resources, we can see that now, if we look at the exclusive resources, we see that the order line table is now exclusive to the order table.

0:18:33.0 AR: So now we didn’t only go over the classes to increase their exclusivity, we also reduced the amount of constraints and increased the exclusivity of the resources that are used by the services creating a better architecture of the system. You can look at the resource report that chose us, the database tables per service, so we have here by database tables, we can see that the order line is used by the order controller, we can also look at it by service and see that the order controller is using these tables right here, and that will also help us in the next phases of the modernization when we don’t only extract the services, but when we look at the data layer and we are connecting the database itself. I want to jump to another application.

0:19:21.4 AR: This is the metric application, it’s a sample application that comes with web logic, and I want to show you here the static dependency. So after we set the boundaries, looking at the runtime dependencies, the resources and the classes, we should look at the static dependencies and what we did before is really trim down the services or expand them a little bit and set the right boundaries, but now we want to get rid of all the compile-time dependencies. Compile-time dependencies are something that gets added with time as you modify the code, and many times there’s lots of classes that you simply don’t need in the service, and the static analysis looking at the dependencies is the right place to trim down the service and reduce it to really what you need to extract with it.

0:20:06.5 AR: So let’s look at the static classes of this service here that’s called, Searching Patient Controller metric is a medical record application, a sample medical record application. So 39 static classes with a pretty high exclusivity, but let’s look at the nonexclusive classes, nonetheless. So we see here a class called, Based Physician page controller, which is an abstract class that it’s used by all the controllers here in the metric application, and when we look at its dependencies what we see is that it requires… So it depends on the physician service, the record service and the patient service being a class that’s widely used. Now for a micro-services architecture, this is not the right architecture, ’cause we’re looking at the searching patient controller, there’s no need for the record service and the patient service to be here.

0:20:57.7 AR: The system even marks those yellow dots as classes that don’t really run, the one thing that does run here is the searching patient controller, and the system lets you, both automatically by setting some parameters and thresholds and manually to define dead code or rather code paths that in this specific service they’re not used, like there may be a record service where this is the only class that’s needed from the space physician page controller, but here in the searching patient controller, it’s not required, so we can just simply mark it as dead code. The system will now calculate all the static dependencies again, and we see that now it’s grayed out, we can do the same for the physician service, and what we’re doing essentially is trimming down the service only to its needed classes.

0:21:48.9 AR: Going back to the services, we’ll now see that the exclusivity was improved, so instead of the 79% that we have before, now it’s 86%, and we can even decide to extract this service, extracting the services is as simple as clicking save, going to the service extraction tab of the application and clicking on download. I’ll pause here. Everything that I showed you is available on a workshop that is including in the assets of this presentation. So I’ll pass it over to you, Bob.

0:22:24.1 BQ: Thanks, Amir. I’d like to walk through a couple of case studies and some real customer stories here about the ROI associated with vFunction. Now vFunction can accelerate these projects, and this is an example of a project by which we accelerated one microservice extraction by 10 times. And in terms of decomposing a full application, we’re able to do it 15 times faster, so we’re seeing much faster execution of modernization projects with vFunction, and actually, in many cases, vFunction is the only means by which they can achieve a practical modernization approach, because otherwise it’s too costly and not even achievable or practical in the first place.

0:23:08.9 BQ: Two key case studies come from two of the largest banks in the world, Intesa Sanpaolo, who is the largest bank in Italy, one of the largest in Europe, one of the top three banks in the United States, and these banks are going through Java Monolith modernization challenges, they have hundreds of applications, if not thousands of applications, they’re trying to modernize. We were able to modernize some of their worst and biggest monoliths, I’d say many times we get challenged with the largest and most complex monolith they have and we welcome that opportunity in any type of POV or POC opportunity. Intesa Sanpaolo is now in the process of modernizing over 450 applications and to build a modernization factory model based on vFunction to do that. And we have… There is case studies that are available and in the assets for this webinar. One of the top banks in the US is actually in that same process, thousands of job applications, and using us to achieve better velocity, be able to apply better DevOps processes and using us to greatly accelerate what was a very slow and sometimes nonarchival process in terms of modernization.

0:24:22.5 BQ: So to summarize and recap of what you’ve seen, the vFunction is AI application modernization and it is a unique and innovative approach to focus on the rearchitecture of your monolithic application, be able to move it into a microservice model in a cloud native environment. We’re using AI and data science, machine learning to really not only accelerate and automate the process, but really improves the accuracy, visibility, lowers the cost and surfaces all those dependencies that were hidden before, thus automating the decomposition process. It’s built for architects and developers, so you are in control of that, as you saw with Amir’s demo, this is an interactive environment, it’s a studio for you to actually interact with this modernization platform, but it also provides a guiding light to actually give you recommendations and a reference architecture is a catalyst for modernization. It’s one of the key things to remember. The current approaches people are using are very manual in nature, they’re using tools that were not built for this purpose, that are not modern and not applying new techniques like AI and machine learning to it. They’re typically manual with overreliance on lift and shift approaches and also very costly in that process too.

0:25:40.2 BQ: So vFunction presents a proven methodology that’s fast and that’s something that’s repeatable in a factory model and then put you in a position to be using continuous modernization as a best practice going forward, where you can begin to lower that technical debt and flip that into innovation in your IT environment. So resources and next step, you’ll see many of them below. We welcome you to come to our website, check out the videos that we have, we have a demo that you can request access to and also portal access to. Reach out to Amir and I on Twitter or feel free to email us at vFunction, I’m bob@vfunction or a variety of tools available and people will be able to interact with you at info@vfunction too. That’s all for now and concludes our formal presentation. Back to you, Vance.

0:26:28.8 Vance: Bob, Amir, really fantastic, really great look at how vFunction gives me some pretty unique and granular X-ray goggles into my 15, 20, 25-year-old legacy application, just to make sure I can get it to cloud cleanly but also to make sure I’m not gonna break anything. So a very terrific session, and I appreciate you both very much. Great to have you.

0:26:48.9 BQ: Thanks, Vance.

0:26:50.8 AR: Thank you, Vance.

0:26:52.9 Vance: Yeah, our pleasure, our pleasure. And thank you both for leaving some time for questions because this certainly did capture a lot of imagination of some of our attendees, especially those from the larger enterprise companies. Let’s start off with this one, you probably get this question a lot guys, where exactly does vFunction run? Does my application data leave my site or require a firewall access? We’re a bit concerned about the security.

0:27:18.6 BQ: Yeah, that’s typically a very common question and vFunction designed to work either on-premise or up in your cloud tenancy and all your data, all information remains in your environment. So it’s behind your firewall, there’s no SaaS equivalent, we’re not pushing things up to a SaaS environment and doing analysis up there, everything stays within your environment and we work within that, so it’s very secure from that perspective, it’s in control. People are using it for onprem applications or for applications that already running up in the cloud themselves. And we’ve been through a variety, as you can imagine, with the banks that we work with and all the financial services organizations, a variety of security checks and have a variety of white papers.

0:28:00.6 Vance: Excellent. Let’s talk about the breadth, I know we were limited on demo time, but does vFunction work on any JWE application, including Spring or WebSphere? I know, Amir, you mentioned WebLogic, just talk about how many different job applications I can point vFunction at.

0:28:16.0 AR: Any major Java framework, we’re starting from Java 6 but we do support all the major application servers, WebLogic, WebSphere, JBoss, WildFly, so all of those with all of the major supported frameworks as well, Spring, etcetera.

0:28:36.7 Vance: Fantastic, fantastic. So we talked a lot about the services part today, I know you guys have so much more functionality, here’s a question that dives into that, does vFunction also decompose the database or just the business logic layer?

0:28:51.0 BQ: That’s another key area in the modernization process. Our dependency analysis and all our analytics look at all the database calls, so part of the microservice recommendations that we use and the rearchitecture approaches take into account trying to decompose where the database calls are. 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 calling portions of a database, those were distinct isolated calls. Therefore, it’s much easier to decompose once you have the rearchitecture process concluded within vFunction. So typically people do the microservice decomposition which takes into account all the database table calls, but then move into a cloud-native database or sometimes they just leave a database as it is because data’s something very sacred to many people, they don’t wanna touch it. It’s all part of how you’re planning to engaging the modernization rollout.

0:29:48.0 Vance: It’s a really good point about the differences, Bob, between the database and the other kind of services or the business logic function. Amir, in your demo, you really highlighted a lot on services and some of the deconstruction or the uncoupling, so to speak, that you did on services seemed like it might require a business user to advise what service was required so something didn’t get broken. Can you walk us through a little bit of whether vFunction is purely for the IT Java person or if there’s some sort of teamwork that’s involved between IT and the business people?

0:30:22.0 AR: I think that software architecture is not completely unlinked from the business and it’s very important to maintain a connection between the architecture that you get from modernizing an application and the business because you have to tie it later on also to the way your R&D is structured, for instance, so teams need to be linked to specific businesses and specific domains, and I think that this is really the point of a domain-driven architecture and micro-services, it’s really to create those vertical services, those business-sensitive services that you can very easily innovate on, that you can involve the R&D process in the business innovation and really bring it back and shift left, if you will, the innovation from the developers to the business.

0:31:17.9 AR: Architects are the key people working with the platform, they definitely do need to know the code. The system does show them quirks and smells currently that’s in their code and their architecture and they do need to react to it, but the system does do a very good job with raising the right questions and defining the right domains. What we see that working with the platform correctly means working with the platform on the one screen and working with your code on another screen, especially when you start the analysis, you kind of say, “Wait, that’s not possible” and then you look at the code and say, “Hmm,” so there’s lots of those aha moments. It’s really good to look at it together. The platform doesn’t need the code but you as an architect usually do need the code.

0:32:07.7 Vance: Yeah, it makes sense, makes sense. And I see time is flying by here, but boy, you guys, you really triggered some great questions here. You both mentioned tech debt in your session, how does vFunction identify a tech debt during the process?

0:32:21.9 AR: Okay. Well, tech debt is really at the core of modernizing, tech debt is what makes your organizations very heavy to innovate. These lean organizations, for every dollar they use on innovation is about 25 cents when 75 go into feeding your tech 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:32:53.4 Vance: This has been really great, guys, and thanks Amir and Bob both for taking us through the intricacies of vFunction and your vision for the tool in helping larger enterprises get their legacy Java resource ready for the cloud. Again, let me thank Amir Rapson, founder and CTO and Bob Quillin, Chief Ecosystem Officer at vFunction. It’s been a great session. Before we close, I think I can squeeze one more in. I think a lot of our attendees, just based on the questions, would like to learn more. Give us a couple of suggestions, next steps. I know that there was mention of a workshop video or some other links and maybe some other assets. So feel free guys, share some next steps.

0:33:29.8 AR: Yeah, I think the most important thing, come to the website, learn more about the product, we have a lot of videos that show demos and use cases. Besides the deeper demos, we actually offer POCs and live demos too, so we can schedule time with you, particularly around your environment. The Medrec application, there’s an entire workshop and there’s a log in, a link below that will lead you to that that can walk you through that more detailed demo and the how-to associate with that. We have a portal too that gets you more and more information, and so there’s a wide variety of ways we love to interact with you and learn more about the challenges you have and how we can help, and feel free to come into our site, reach out if you have questions, I’m bob@vfunction, there’s info and there’s contact us information also below. So like I said, lots of resources available to you, learn more about what we do and when you’re ready, feel free to ping us on our… We’re happy to engage.

0:34:24.6 Vance: Absolutely. Thanks, Bob and thanks Amir very much. Just a note to our attendees, we’ve got many of the resources right here under the view screen, take a look at those. And I highly recommend for those of you that have been investing time in your modernization or deconstructing some of your JWE resources, that you take a look at vFunction, they’ve really been a pure innovator in this space, saving a lot of time and reducing risk, which is another key factor that goes along with any sort of migration strategy. Just a note here, you can tell there’s a lot of innovation and thought going on at vFunction, we didn’t have room for everything, here’s the slides. It’ll take you directly to the vFunction website for any of the resources Bob mentioned but also for many others we just didn’t have room for. Thanks again to our speakers and our audience, really terrific questions, thanks for making this a great session.

Technology leaders can now evaluate the cost of technical debt, determine what to modernize first, and then take action – all in one platform.